The Tor Browser / file comparison

comparison: security/nss/lib/pk11wrap/pk11mech.c

security/nss/lib/pk11wrap/pk11mech.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:701cb6988b76
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 maps various PKCS #11 Mechanisms to related mechanisms, key
6 * types, and ASN.1 encodings.
7 */
8 #include "seccomon.h"
9 #include "secmod.h"
10 #include "secmodi.h"
11 #include "pkcs11t.h"
12 #include "pk11func.h"
13 #include "secitem.h"
14 #include "secder.h"
15 #include "secasn1.h"
16 #include "secoid.h"
17 #include "secerr.h"
18
19 /*************************************************************
20 * local static and global data
21 *************************************************************/
22
23 /*
24 * Tables used for Extended mechanism mapping (currently not used)
25 */
26 typedef struct {
27 CK_MECHANISM_TYPE keyGen;
28 CK_KEY_TYPE keyType;
29 CK_MECHANISM_TYPE type;
30 CK_MECHANISM_TYPE padType;
31 int blockSize;
32 int iv;
33 } pk11MechanismData;
34
35 static pk11MechanismData pk11_default =
36 { CKM_GENERIC_SECRET_KEY_GEN, CKK_GENERIC_SECRET,
37 CKM_FAKE_RANDOM, CKM_FAKE_RANDOM, 8, 8 };
38 static pk11MechanismData *pk11_MechanismTable = NULL;
39 static int pk11_MechTableSize = 0;
40 static int pk11_MechEntrySize = 0;
41
42 /*
43 * list of mechanisms we're willing to wrap secret keys with.
44 * This list is ordered by preference.
45 */
46 CK_MECHANISM_TYPE wrapMechanismList[] = {
47 CKM_DES3_ECB,
48 CKM_CAST5_ECB,
49 CKM_AES_ECB,
50 CKM_CAMELLIA_ECB,
51 CKM_SEED_ECB,
52 CKM_CAST5_ECB,
53 CKM_DES_ECB,
54 CKM_KEY_WRAP_LYNKS,
55 CKM_IDEA_ECB,
56 CKM_CAST3_ECB,
57 CKM_CAST_ECB,
58 CKM_RC5_ECB,
59 CKM_RC2_ECB,
60 CKM_CDMF_ECB,
61 CKM_SKIPJACK_WRAP,
62 };
63
64 int wrapMechanismCount = sizeof(wrapMechanismList)/sizeof(wrapMechanismList[0]);
65
66 /*********************************************************************
67 * Mechanism Mapping functions
68 *********************************************************************/
69
70 /*
71 * lookup an entry in the mechanism table. If none found, return the
72 * default structure.
73 */
74 static pk11MechanismData *
75 pk11_lookup(CK_MECHANISM_TYPE type)
76 {
77 int i;
78 for (i=0; i < pk11_MechEntrySize; i++) {
79 if (pk11_MechanismTable[i].type == type) {
80 return (&pk11_MechanismTable[i]);
81 }
82 }
83 return &pk11_default;
84 }
85
86 /*
87 * find the best key wrap mechanism for this slot.
88 */
89 CK_MECHANISM_TYPE
90 PK11_GetBestWrapMechanism(PK11SlotInfo *slot)
91 {
92 int i;
93 for (i=0; i < wrapMechanismCount; i++) {
94 if (PK11_DoesMechanism(slot,wrapMechanismList[i])) {
95 return wrapMechanismList[i];
96 }
97 }
98 return CKM_INVALID_MECHANISM;
99 }
100
101 /*
102 * NOTE: This is not thread safe. Called at init time, and when loading
103 * a new Entry. It is reasonably safe as long as it is not re-entered
104 * (readers will always see a consistant table)
105 *
106 * This routine is called to add entries to the mechanism table, once there,
107 * they can not be removed.
108 */
109 void
110 PK11_AddMechanismEntry(CK_MECHANISM_TYPE type, CK_KEY_TYPE key,
111 CK_MECHANISM_TYPE keyGen,
112 CK_MECHANISM_TYPE padType,
113 int ivLen, int blockSize)
114 {
115 int tableSize = pk11_MechTableSize;
116 int size = pk11_MechEntrySize;
117 int entry = size++;
118 pk11MechanismData *old = pk11_MechanismTable;
119 pk11MechanismData *newt = pk11_MechanismTable;
120
121
122 if (size > tableSize) {
123 int oldTableSize = tableSize;
124 tableSize += 10;
125 newt = PORT_NewArray(pk11MechanismData, tableSize);
126 if (newt == NULL) return;
127
128 if (old) PORT_Memcpy(newt, old, oldTableSize*sizeof(*newt));
129 } else old = NULL;
130
131 newt[entry].type = type;
132 newt[entry].keyType = key;
133 newt[entry].keyGen = keyGen;
134 newt[entry].padType = padType;
135 newt[entry].iv = ivLen;
136 newt[entry].blockSize = blockSize;
137
138 pk11_MechanismTable = newt;
139 pk11_MechTableSize = tableSize;
140 pk11_MechEntrySize = size;
141 if (old) PORT_Free(old);
142 }
143
144 /*
145 * Get the mechanism needed for the given key type
146 */
147 CK_MECHANISM_TYPE
148 PK11_GetKeyMechanism(CK_KEY_TYPE type)
149 {
150 switch (type) {
151 case CKK_SEED:
152 return CKM_SEED_CBC;
153 case CKK_CAMELLIA:
154 return CKM_CAMELLIA_CBC;
155 case CKK_AES:
156 return CKM_AES_CBC;
157 case CKK_DES:
158 return CKM_DES_CBC;
159 case CKK_DES3:
160 return CKM_DES3_KEY_GEN;
161 case CKK_DES2:
162 return CKM_DES2_KEY_GEN;
163 case CKK_CDMF:
164 return CKM_CDMF_CBC;
165 case CKK_RC2:
166 return CKM_RC2_CBC;
167 case CKK_RC4:
168 return CKM_RC4;
169 case CKK_RC5:
170 return CKM_RC5_CBC;
171 case CKK_SKIPJACK:
172 return CKM_SKIPJACK_CBC64;
173 case CKK_BATON:
174 return CKM_BATON_CBC128;
175 case CKK_JUNIPER:
176 return CKM_JUNIPER_CBC128;
177 case CKK_IDEA:
178 return CKM_IDEA_CBC;
179 case CKK_CAST:
180 return CKM_CAST_CBC;
181 case CKK_CAST3:
182 return CKM_CAST3_CBC;
183 case CKK_CAST5:
184 return CKM_CAST5_CBC;
185 case CKK_RSA:
186 return CKM_RSA_PKCS;
187 case CKK_DSA:
188 return CKM_DSA;
189 case CKK_DH:
190 return CKM_DH_PKCS_DERIVE;
191 case CKK_KEA:
192 return CKM_KEA_KEY_DERIVE;
193 case CKK_EC: /* CKK_ECDSA is deprecated */
194 return CKM_ECDSA;
195 case CKK_GENERIC_SECRET:
196 default:
197 return CKM_SHA_1_HMAC;
198 }
199 }
200
201 /*
202 * Get the key type needed for the given mechanism
203 */
204 CK_KEY_TYPE
205 PK11_GetKeyType(CK_MECHANISM_TYPE type,unsigned long len)
206 {
207 switch (type) {
208 case CKM_SEED_ECB:
209 case CKM_SEED_CBC:
210 case CKM_SEED_MAC:
211 case CKM_SEED_MAC_GENERAL:
212 case CKM_SEED_CBC_PAD:
213 case CKM_SEED_KEY_GEN:
214 return CKK_SEED;
215 case CKM_CAMELLIA_ECB:
216 case CKM_CAMELLIA_CBC:
217 case CKM_CAMELLIA_MAC:
218 case CKM_CAMELLIA_MAC_GENERAL:
219 case CKM_CAMELLIA_CBC_PAD:
220 case CKM_CAMELLIA_KEY_GEN:
221 return CKK_CAMELLIA;
222 case CKM_AES_ECB:
223 case CKM_AES_CBC:
224 case CKM_AES_CCM:
225 case CKM_AES_CTR:
226 case CKM_AES_CTS:
227 case CKM_AES_GCM:
228 case CKM_AES_MAC:
229 case CKM_AES_MAC_GENERAL:
230 case CKM_AES_CBC_PAD:
231 case CKM_AES_KEY_GEN:
232 case CKM_NETSCAPE_AES_KEY_WRAP:
233 case CKM_NETSCAPE_AES_KEY_WRAP_PAD:
234 return CKK_AES;
235 case CKM_DES_ECB:
236 case CKM_DES_CBC:
237 case CKM_DES_MAC:
238 case CKM_DES_MAC_GENERAL:
239 case CKM_DES_CBC_PAD:
240 case CKM_DES_KEY_GEN:
241 case CKM_KEY_WRAP_LYNKS:
242 case CKM_PBE_MD2_DES_CBC:
243 case CKM_PBE_MD5_DES_CBC:
244 return CKK_DES;
245 case CKM_DES3_ECB:
246 case CKM_DES3_CBC:
247 case CKM_DES3_MAC:
248 case CKM_DES3_MAC_GENERAL:
249 case CKM_DES3_CBC_PAD:
250 return (len == 16) ? CKK_DES2 : CKK_DES3;
251 case CKM_DES2_KEY_GEN:
252 case CKM_PBE_SHA1_DES2_EDE_CBC:
253 return CKK_DES2;
254 case CKM_PBE_SHA1_DES3_EDE_CBC:
255 case CKM_DES3_KEY_GEN:
256 return CKK_DES3;
257 case CKM_CDMF_ECB:
258 case CKM_CDMF_CBC:
259 case CKM_CDMF_MAC:
260 case CKM_CDMF_MAC_GENERAL:
261 case CKM_CDMF_CBC_PAD:
262 case CKM_CDMF_KEY_GEN:
263 return CKK_CDMF;
264 case CKM_RC2_ECB:
265 case CKM_RC2_CBC:
266 case CKM_RC2_MAC:
267 case CKM_RC2_MAC_GENERAL:
268 case CKM_RC2_CBC_PAD:
269 case CKM_RC2_KEY_GEN:
270 case CKM_PBE_SHA1_RC2_128_CBC:
271 case CKM_PBE_SHA1_RC2_40_CBC:
272 return CKK_RC2;
273 case CKM_RC4:
274 case CKM_RC4_KEY_GEN:
275 return CKK_RC4;
276 case CKM_RC5_ECB:
277 case CKM_RC5_CBC:
278 case CKM_RC5_MAC:
279 case CKM_RC5_MAC_GENERAL:
280 case CKM_RC5_CBC_PAD:
281 case CKM_RC5_KEY_GEN:
282 return CKK_RC5;
283 case CKM_SKIPJACK_CBC64:
284 case CKM_SKIPJACK_ECB64:
285 case CKM_SKIPJACK_OFB64:
286 case CKM_SKIPJACK_CFB64:
287 case CKM_SKIPJACK_CFB32:
288 case CKM_SKIPJACK_CFB16:
289 case CKM_SKIPJACK_CFB8:
290 case CKM_SKIPJACK_KEY_GEN:
291 case CKM_SKIPJACK_WRAP:
292 case CKM_SKIPJACK_PRIVATE_WRAP:
293 return CKK_SKIPJACK;
294 case CKM_BATON_ECB128:
295 case CKM_BATON_ECB96:
296 case CKM_BATON_CBC128:
297 case CKM_BATON_COUNTER:
298 case CKM_BATON_SHUFFLE:
299 case CKM_BATON_WRAP:
300 case CKM_BATON_KEY_GEN:
301 return CKK_BATON;
302 case CKM_JUNIPER_ECB128:
303 case CKM_JUNIPER_CBC128:
304 case CKM_JUNIPER_COUNTER:
305 case CKM_JUNIPER_SHUFFLE:
306 case CKM_JUNIPER_WRAP:
307 case CKM_JUNIPER_KEY_GEN:
308 return CKK_JUNIPER;
309 case CKM_IDEA_CBC:
310 case CKM_IDEA_ECB:
311 case CKM_IDEA_MAC:
312 case CKM_IDEA_MAC_GENERAL:
313 case CKM_IDEA_CBC_PAD:
314 case CKM_IDEA_KEY_GEN:
315 return CKK_IDEA;
316 case CKM_CAST_ECB:
317 case CKM_CAST_CBC:
318 case CKM_CAST_MAC:
319 case CKM_CAST_MAC_GENERAL:
320 case CKM_CAST_CBC_PAD:
321 case CKM_CAST_KEY_GEN:
322 case CKM_PBE_MD5_CAST_CBC:
323 return CKK_CAST;
324 case CKM_CAST3_ECB:
325 case CKM_CAST3_CBC:
326 case CKM_CAST3_MAC:
327 case CKM_CAST3_MAC_GENERAL:
328 case CKM_CAST3_CBC_PAD:
329 case CKM_CAST3_KEY_GEN:
330 case CKM_PBE_MD5_CAST3_CBC:
331 return CKK_CAST3;
332 case CKM_CAST5_ECB:
333 case CKM_CAST5_CBC:
334 case CKM_CAST5_MAC:
335 case CKM_CAST5_MAC_GENERAL:
336 case CKM_CAST5_CBC_PAD:
337 case CKM_CAST5_KEY_GEN:
338 case CKM_PBE_MD5_CAST5_CBC:
339 return CKK_CAST5;
340 case CKM_RSA_PKCS:
341 case CKM_RSA_9796:
342 case CKM_RSA_X_509:
343 case CKM_MD2_RSA_PKCS:
344 case CKM_MD5_RSA_PKCS:
345 case CKM_SHA1_RSA_PKCS:
346 case CKM_SHA224_RSA_PKCS:
347 case CKM_SHA256_RSA_PKCS:
348 case CKM_SHA384_RSA_PKCS:
349 case CKM_SHA512_RSA_PKCS:
350 case CKM_KEY_WRAP_SET_OAEP:
351 case CKM_RSA_PKCS_KEY_PAIR_GEN:
352 case CKM_RSA_X9_31_KEY_PAIR_GEN:
353 return CKK_RSA;
354 case CKM_DSA:
355 case CKM_DSA_SHA1:
356 case CKM_DSA_KEY_PAIR_GEN:
357 return CKK_DSA;
358 case CKM_DH_PKCS_DERIVE:
359 case CKM_DH_PKCS_KEY_PAIR_GEN:
360 return CKK_DH;
361 case CKM_KEA_KEY_DERIVE:
362 case CKM_KEA_KEY_PAIR_GEN:
363 return CKK_KEA;
364 case CKM_ECDSA:
365 case CKM_ECDSA_SHA1:
366 case CKM_EC_KEY_PAIR_GEN: /* aka CKM_ECDSA_KEY_PAIR_GEN */
367 case CKM_ECDH1_DERIVE:
368 return CKK_EC; /* CKK_ECDSA is deprecated */
369 case CKM_SSL3_PRE_MASTER_KEY_GEN:
370 case CKM_GENERIC_SECRET_KEY_GEN:
371 case CKM_SSL3_MASTER_KEY_DERIVE:
372 case CKM_SSL3_MASTER_KEY_DERIVE_DH:
373 case CKM_SSL3_KEY_AND_MAC_DERIVE:
374 case CKM_SSL3_SHA1_MAC:
375 case CKM_SSL3_MD5_MAC:
376 case CKM_TLS_MASTER_KEY_DERIVE:
377 case CKM_NSS_TLS_MASTER_KEY_DERIVE_SHA256:
378 case CKM_TLS_MASTER_KEY_DERIVE_DH:
379 case CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256:
380 case CKM_TLS_KEY_AND_MAC_DERIVE:
381 case CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256:
382 case CKM_SHA_1_HMAC:
383 case CKM_SHA_1_HMAC_GENERAL:
384 case CKM_SHA224_HMAC:
385 case CKM_SHA224_HMAC_GENERAL:
386 case CKM_SHA256_HMAC:
387 case CKM_SHA256_HMAC_GENERAL:
388 case CKM_SHA384_HMAC:
389 case CKM_SHA384_HMAC_GENERAL:
390 case CKM_SHA512_HMAC:
391 case CKM_SHA512_HMAC_GENERAL:
392 case CKM_MD2_HMAC:
393 case CKM_MD2_HMAC_GENERAL:
394 case CKM_MD5_HMAC:
395 case CKM_MD5_HMAC_GENERAL:
396 case CKM_TLS_PRF_GENERAL:
397 case CKM_NSS_TLS_PRF_GENERAL_SHA256:
398 return CKK_GENERIC_SECRET;
399 default:
400 return pk11_lookup(type)->keyType;
401 }
402 }
403
404 /*
405 * Get the Key Gen Mechanism needed for the given
406 * crypto mechanism
407 */
408 CK_MECHANISM_TYPE
409 PK11_GetKeyGen(CK_MECHANISM_TYPE type)
410 {
411 return PK11_GetKeyGenWithSize(type, 0);
412 }
413
414 CK_MECHANISM_TYPE
415 PK11_GetKeyGenWithSize(CK_MECHANISM_TYPE type, int size)
416 {
417 switch (type) {
418 case CKM_SEED_ECB:
419 case CKM_SEED_CBC:
420 case CKM_SEED_MAC:
421 case CKM_SEED_MAC_GENERAL:
422 case CKM_SEED_CBC_PAD:
423 case CKM_SEED_KEY_GEN:
424 return CKM_SEED_KEY_GEN;
425 case CKM_CAMELLIA_ECB:
426 case CKM_CAMELLIA_CBC:
427 case CKM_CAMELLIA_MAC:
428 case CKM_CAMELLIA_MAC_GENERAL:
429 case CKM_CAMELLIA_CBC_PAD:
430 case CKM_CAMELLIA_KEY_GEN:
431 return CKM_CAMELLIA_KEY_GEN;
432 case CKM_AES_ECB:
433 case CKM_AES_CBC:
434 case CKM_AES_CCM:
435 case CKM_AES_CTR:
436 case CKM_AES_CTS:
437 case CKM_AES_GCM:
438 case CKM_AES_MAC:
439 case CKM_AES_MAC_GENERAL:
440 case CKM_AES_CBC_PAD:
441 case CKM_AES_KEY_GEN:
442 return CKM_AES_KEY_GEN;
443 case CKM_DES_ECB:
444 case CKM_DES_CBC:
445 case CKM_DES_MAC:
446 case CKM_DES_MAC_GENERAL:
447 case CKM_KEY_WRAP_LYNKS:
448 case CKM_DES_CBC_PAD:
449 case CKM_DES_KEY_GEN:
450 return CKM_DES_KEY_GEN;
451 case CKM_DES3_ECB:
452 case CKM_DES3_CBC:
453 case CKM_DES3_MAC:
454 case CKM_DES3_MAC_GENERAL:
455 case CKM_DES3_CBC_PAD:
456 return (size == 16) ? CKM_DES2_KEY_GEN : CKM_DES3_KEY_GEN;
457 case CKM_DES3_KEY_GEN:
458 return CKM_DES3_KEY_GEN;
459 case CKM_DES2_KEY_GEN:
460 return CKM_DES2_KEY_GEN;
461 case CKM_CDMF_ECB:
462 case CKM_CDMF_CBC:
463 case CKM_CDMF_MAC:
464 case CKM_CDMF_MAC_GENERAL:
465 case CKM_CDMF_CBC_PAD:
466 case CKM_CDMF_KEY_GEN:
467 return CKM_CDMF_KEY_GEN;
468 case CKM_RC2_ECB:
469 case CKM_RC2_CBC:
470 case CKM_RC2_MAC:
471 case CKM_RC2_MAC_GENERAL:
472 case CKM_RC2_CBC_PAD:
473 case CKM_RC2_KEY_GEN:
474 return CKM_RC2_KEY_GEN;
475 case CKM_RC4:
476 case CKM_RC4_KEY_GEN:
477 return CKM_RC4_KEY_GEN;
478 case CKM_RC5_ECB:
479 case CKM_RC5_CBC:
480 case CKM_RC5_MAC:
481 case CKM_RC5_MAC_GENERAL:
482 case CKM_RC5_CBC_PAD:
483 case CKM_RC5_KEY_GEN:
484 return CKM_RC5_KEY_GEN;
485 case CKM_SKIPJACK_CBC64:
486 case CKM_SKIPJACK_ECB64:
487 case CKM_SKIPJACK_OFB64:
488 case CKM_SKIPJACK_CFB64:
489 case CKM_SKIPJACK_CFB32:
490 case CKM_SKIPJACK_CFB16:
491 case CKM_SKIPJACK_CFB8:
492 case CKM_SKIPJACK_WRAP:
493 case CKM_SKIPJACK_KEY_GEN:
494 return CKM_SKIPJACK_KEY_GEN;
495 case CKM_BATON_ECB128:
496 case CKM_BATON_ECB96:
497 case CKM_BATON_CBC128:
498 case CKM_BATON_COUNTER:
499 case CKM_BATON_SHUFFLE:
500 case CKM_BATON_WRAP:
501 case CKM_BATON_KEY_GEN:
502 return CKM_BATON_KEY_GEN;
503 case CKM_JUNIPER_ECB128:
504 case CKM_JUNIPER_CBC128:
505 case CKM_JUNIPER_COUNTER:
506 case CKM_JUNIPER_SHUFFLE:
507 case CKM_JUNIPER_WRAP:
508 case CKM_JUNIPER_KEY_GEN:
509 return CKM_JUNIPER_KEY_GEN;
510 case CKM_IDEA_CBC:
511 case CKM_IDEA_ECB:
512 case CKM_IDEA_MAC:
513 case CKM_IDEA_MAC_GENERAL:
514 case CKM_IDEA_CBC_PAD:
515 case CKM_IDEA_KEY_GEN:
516 return CKM_IDEA_KEY_GEN;
517 case CKM_CAST_ECB:
518 case CKM_CAST_CBC:
519 case CKM_CAST_MAC:
520 case CKM_CAST_MAC_GENERAL:
521 case CKM_CAST_CBC_PAD:
522 case CKM_CAST_KEY_GEN:
523 return CKM_CAST_KEY_GEN;
524 case CKM_CAST3_ECB:
525 case CKM_CAST3_CBC:
526 case CKM_CAST3_MAC:
527 case CKM_CAST3_MAC_GENERAL:
528 case CKM_CAST3_CBC_PAD:
529 case CKM_CAST3_KEY_GEN:
530 return CKM_CAST3_KEY_GEN;
531 case CKM_CAST5_ECB:
532 case CKM_CAST5_CBC:
533 case CKM_CAST5_MAC:
534 case CKM_CAST5_MAC_GENERAL:
535 case CKM_CAST5_CBC_PAD:
536 case CKM_CAST5_KEY_GEN:
537 return CKM_CAST5_KEY_GEN;
538 case CKM_RSA_PKCS:
539 case CKM_RSA_9796:
540 case CKM_RSA_X_509:
541 case CKM_MD2_RSA_PKCS:
542 case CKM_MD5_RSA_PKCS:
543 case CKM_SHA1_RSA_PKCS:
544 case CKM_SHA224_RSA_PKCS:
545 case CKM_SHA256_RSA_PKCS:
546 case CKM_SHA384_RSA_PKCS:
547 case CKM_SHA512_RSA_PKCS:
548 case CKM_KEY_WRAP_SET_OAEP:
549 case CKM_RSA_PKCS_KEY_PAIR_GEN:
550 return CKM_RSA_PKCS_KEY_PAIR_GEN;
551 case CKM_RSA_X9_31_KEY_PAIR_GEN:
552 return CKM_RSA_X9_31_KEY_PAIR_GEN;
553 case CKM_DSA:
554 case CKM_DSA_SHA1:
555 case CKM_DSA_KEY_PAIR_GEN:
556 return CKM_DSA_KEY_PAIR_GEN;
557 case CKM_DH_PKCS_DERIVE:
558 case CKM_DH_PKCS_KEY_PAIR_GEN:
559 return CKM_DH_PKCS_KEY_PAIR_GEN;
560 case CKM_KEA_KEY_DERIVE:
561 case CKM_KEA_KEY_PAIR_GEN:
562 return CKM_KEA_KEY_PAIR_GEN;
563 case CKM_ECDSA:
564 case CKM_ECDSA_SHA1:
565 case CKM_EC_KEY_PAIR_GEN: /* aka CKM_ECDSA_KEY_PAIR_GEN */
566 case CKM_ECDH1_DERIVE:
567 return CKM_EC_KEY_PAIR_GEN;
568 case CKM_SSL3_PRE_MASTER_KEY_GEN:
569 case CKM_SSL3_MASTER_KEY_DERIVE:
570 case CKM_SSL3_KEY_AND_MAC_DERIVE:
571 case CKM_SSL3_SHA1_MAC:
572 case CKM_SSL3_MD5_MAC:
573 case CKM_TLS_MASTER_KEY_DERIVE:
574 case CKM_TLS_KEY_AND_MAC_DERIVE:
575 case CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256:
576 return CKM_SSL3_PRE_MASTER_KEY_GEN;
577 case CKM_SHA_1_HMAC:
578 case CKM_SHA_1_HMAC_GENERAL:
579 case CKM_SHA224_HMAC:
580 case CKM_SHA224_HMAC_GENERAL:
581 case CKM_SHA256_HMAC:
582 case CKM_SHA256_HMAC_GENERAL:
583 case CKM_SHA384_HMAC:
584 case CKM_SHA384_HMAC_GENERAL:
585 case CKM_SHA512_HMAC:
586 case CKM_SHA512_HMAC_GENERAL:
587 case CKM_MD2_HMAC:
588 case CKM_MD2_HMAC_GENERAL:
589 case CKM_MD5_HMAC:
590 case CKM_MD5_HMAC_GENERAL:
591 case CKM_TLS_PRF_GENERAL:
592 case CKM_NSS_TLS_PRF_GENERAL_SHA256:
593 case CKM_GENERIC_SECRET_KEY_GEN:
594 return CKM_GENERIC_SECRET_KEY_GEN;
595 case CKM_PBE_MD2_DES_CBC:
596 case CKM_PBE_MD5_DES_CBC:
597 case CKM_PBA_SHA1_WITH_SHA1_HMAC:
598 case CKM_NETSCAPE_PBE_SHA1_HMAC_KEY_GEN:
599 case CKM_NETSCAPE_PBE_MD5_HMAC_KEY_GEN:
600 case CKM_NETSCAPE_PBE_MD2_HMAC_KEY_GEN:
601 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:
602 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:
603 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:
604 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:
605 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:
606 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:
607 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:
608 case CKM_PBE_SHA1_RC2_40_CBC:
609 case CKM_PBE_SHA1_RC2_128_CBC:
610 case CKM_PBE_SHA1_RC4_40:
611 case CKM_PBE_SHA1_RC4_128:
612 case CKM_PBE_SHA1_DES3_EDE_CBC:
613 case CKM_PBE_SHA1_DES2_EDE_CBC:
614 case CKM_PKCS5_PBKD2:
615 return type;
616 default:
617 return pk11_lookup(type)->keyGen;
618 }
619 }
620
621 /*
622 * get the mechanism block size
623 */
624 int
625 PK11_GetBlockSize(CK_MECHANISM_TYPE type,SECItem *params)
626 {
627 CK_RC5_PARAMS *rc5_params;
628 CK_RC5_CBC_PARAMS *rc5_cbc_params;
629 switch (type) {
630 case CKM_RC5_ECB:
631 if ((params) && (params->data)) {
632 rc5_params = (CK_RC5_PARAMS *) params->data;
633 return (rc5_params->ulWordsize)*2;
634 }
635 return 8;
636 case CKM_RC5_CBC:
637 case CKM_RC5_CBC_PAD:
638 if ((params) && (params->data)) {
639 rc5_cbc_params = (CK_RC5_CBC_PARAMS *) params->data;
640 return (rc5_cbc_params->ulWordsize)*2;
641 }
642 return 8;
643 case CKM_DES_ECB:
644 case CKM_DES3_ECB:
645 case CKM_RC2_ECB:
646 case CKM_IDEA_ECB:
647 case CKM_CAST_ECB:
648 case CKM_CAST3_ECB:
649 case CKM_CAST5_ECB:
650 case CKM_RC2_CBC:
651 case CKM_SKIPJACK_CBC64:
652 case CKM_SKIPJACK_ECB64:
653 case CKM_SKIPJACK_OFB64:
654 case CKM_SKIPJACK_CFB64:
655 case CKM_DES_CBC:
656 case CKM_DES3_CBC:
657 case CKM_IDEA_CBC:
658 case CKM_CAST_CBC:
659 case CKM_CAST3_CBC:
660 case CKM_CAST5_CBC:
661 case CKM_DES_CBC_PAD:
662 case CKM_DES3_CBC_PAD:
663 case CKM_RC2_CBC_PAD:
664 case CKM_IDEA_CBC_PAD:
665 case CKM_CAST_CBC_PAD:
666 case CKM_CAST3_CBC_PAD:
667 case CKM_CAST5_CBC_PAD:
668 case CKM_PBE_MD2_DES_CBC:
669 case CKM_PBE_MD5_DES_CBC:
670 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:
671 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:
672 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:
673 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:
674 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:
675 case CKM_PBE_SHA1_RC2_40_CBC:
676 case CKM_PBE_SHA1_RC2_128_CBC:
677 case CKM_PBE_SHA1_DES3_EDE_CBC:
678 case CKM_PBE_SHA1_DES2_EDE_CBC:
679 return 8;
680 case CKM_SKIPJACK_CFB32:
681 case CKM_SKIPJACK_CFB16:
682 case CKM_SKIPJACK_CFB8:
683 return 4;
684 case CKM_SEED_ECB:
685 case CKM_SEED_CBC:
686 case CKM_SEED_CBC_PAD:
687 case CKM_CAMELLIA_ECB:
688 case CKM_CAMELLIA_CBC:
689 case CKM_CAMELLIA_CBC_PAD:
690 case CKM_AES_ECB:
691 case CKM_AES_CBC:
692 case CKM_AES_CBC_PAD:
693 case CKM_BATON_ECB128:
694 case CKM_BATON_CBC128:
695 case CKM_BATON_COUNTER:
696 case CKM_BATON_SHUFFLE:
697 case CKM_JUNIPER_ECB128:
698 case CKM_JUNIPER_CBC128:
699 case CKM_JUNIPER_COUNTER:
700 case CKM_JUNIPER_SHUFFLE:
701 return 16;
702 case CKM_BATON_ECB96:
703 return 12;
704 case CKM_RC4:
705 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:
706 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:
707 case CKM_PBE_SHA1_RC4_40:
708 case CKM_PBE_SHA1_RC4_128:
709 return 0;
710 case CKM_RSA_PKCS:
711 case CKM_RSA_9796:
712 case CKM_RSA_X_509:
713 /*actually it's the modulus length of the key!*/
714 return -1; /* failure */
715 default:
716 return pk11_lookup(type)->blockSize;
717 }
718 }
719
720 /*
721 * get the iv length
722 */
723 int
724 PK11_GetIVLength(CK_MECHANISM_TYPE type)
725 {
726 switch (type) {
727 case CKM_SEED_ECB:
728 case CKM_CAMELLIA_ECB:
729 case CKM_AES_ECB:
730 case CKM_DES_ECB:
731 case CKM_DES3_ECB:
732 case CKM_RC2_ECB:
733 case CKM_IDEA_ECB:
734 case CKM_SKIPJACK_WRAP:
735 case CKM_BATON_WRAP:
736 case CKM_RC5_ECB:
737 case CKM_CAST_ECB:
738 case CKM_CAST3_ECB:
739 case CKM_CAST5_ECB:
740 return 0;
741 case CKM_RC2_CBC:
742 case CKM_DES_CBC:
743 case CKM_DES3_CBC:
744 case CKM_IDEA_CBC:
745 case CKM_PBE_MD2_DES_CBC:
746 case CKM_PBE_MD5_DES_CBC:
747 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:
748 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:
749 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:
750 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:
751 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:
752 case CKM_PBE_SHA1_RC2_40_CBC:
753 case CKM_PBE_SHA1_RC2_128_CBC:
754 case CKM_PBE_SHA1_DES3_EDE_CBC:
755 case CKM_PBE_SHA1_DES2_EDE_CBC:
756 case CKM_RC5_CBC:
757 case CKM_CAST_CBC:
758 case CKM_CAST3_CBC:
759 case CKM_CAST5_CBC:
760 case CKM_RC2_CBC_PAD:
761 case CKM_DES_CBC_PAD:
762 case CKM_DES3_CBC_PAD:
763 case CKM_IDEA_CBC_PAD:
764 case CKM_RC5_CBC_PAD:
765 case CKM_CAST_CBC_PAD:
766 case CKM_CAST3_CBC_PAD:
767 case CKM_CAST5_CBC_PAD:
768 return 8;
769 case CKM_SEED_CBC:
770 case CKM_SEED_CBC_PAD:
771 case CKM_CAMELLIA_CBC:
772 case CKM_CAMELLIA_CBC_PAD:
773 case CKM_AES_CBC:
774 case CKM_AES_CBC_PAD:
775 return 16;
776 case CKM_SKIPJACK_CBC64:
777 case CKM_SKIPJACK_ECB64:
778 case CKM_SKIPJACK_OFB64:
779 case CKM_SKIPJACK_CFB64:
780 case CKM_SKIPJACK_CFB32:
781 case CKM_SKIPJACK_CFB16:
782 case CKM_SKIPJACK_CFB8:
783 case CKM_BATON_ECB128:
784 case CKM_BATON_ECB96:
785 case CKM_BATON_CBC128:
786 case CKM_BATON_COUNTER:
787 case CKM_BATON_SHUFFLE:
788 case CKM_JUNIPER_ECB128:
789 case CKM_JUNIPER_CBC128:
790 case CKM_JUNIPER_COUNTER:
791 case CKM_JUNIPER_SHUFFLE:
792 return 24;
793 case CKM_RC4:
794 case CKM_RSA_PKCS:
795 case CKM_RSA_9796:
796 case CKM_RSA_X_509:
797 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:
798 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:
799 case CKM_PBE_SHA1_RC4_40:
800 case CKM_PBE_SHA1_RC4_128:
801 return 0;
802 default:
803 return pk11_lookup(type)->iv;
804 }
805 }
806
807
808 /* These next two utilities are here to help facilitate future
809 * Dynamic Encrypt/Decrypt symetric key mechanisms, and to allow functions
810 * like SSL and S-MIME to automatically add them.
811 */
812 SECItem *
813 pk11_ParamFromIVWithLen(CK_MECHANISM_TYPE type, SECItem *iv, int keyLen)
814 {
815 CK_RC2_CBC_PARAMS *rc2_params = NULL;
816 CK_RC2_PARAMS *rc2_ecb_params = NULL;
817 CK_RC5_PARAMS *rc5_params = NULL;
818 CK_RC5_CBC_PARAMS *rc5_cbc_params = NULL;
819 SECItem *param;
820
821 param = (SECItem *)PORT_Alloc(sizeof(SECItem));
822 if (param == NULL) return NULL;
823 param->data = NULL;
824 param->len = 0;
825 param->type = 0;
826 switch (type) {
827 case CKM_SEED_ECB:
828 case CKM_CAMELLIA_ECB:
829 case CKM_AES_ECB:
830 case CKM_DES_ECB:
831 case CKM_DES3_ECB:
832 case CKM_RSA_PKCS:
833 case CKM_RSA_X_509:
834 case CKM_RSA_9796:
835 case CKM_IDEA_ECB:
836 case CKM_CDMF_ECB:
837 case CKM_CAST_ECB:
838 case CKM_CAST3_ECB:
839 case CKM_CAST5_ECB:
840 case CKM_RC4:
841 break;
842 case CKM_RC2_ECB:
843 rc2_ecb_params = (CK_RC2_PARAMS *)PORT_Alloc(sizeof(CK_RC2_PARAMS));
844 if (rc2_ecb_params == NULL) break;
845 /* Maybe we should pass the key size in too to get this value? */
846 *rc2_ecb_params = keyLen ? keyLen*8 : 128;
847 param->data = (unsigned char *) rc2_ecb_params;
848 param->len = sizeof(CK_RC2_PARAMS);
849 break;
850 case CKM_RC2_CBC:
851 case CKM_RC2_CBC_PAD:
852 rc2_params = (CK_RC2_CBC_PARAMS *)PORT_Alloc(sizeof(CK_RC2_CBC_PARAMS));
853 if (rc2_params == NULL) break;
854 /* Maybe we should pass the key size in too to get this value? */
855 rc2_params->ulEffectiveBits = keyLen ? keyLen*8 : 128;
856 if (iv && iv->data)
857 PORT_Memcpy(rc2_params->iv,iv->data,sizeof(rc2_params->iv));
858 param->data = (unsigned char *) rc2_params;
859 param->len = sizeof(CK_RC2_CBC_PARAMS);
860 break;
861 case CKM_RC5_CBC:
862 case CKM_RC5_CBC_PAD:
863 rc5_cbc_params = (CK_RC5_CBC_PARAMS *)
864 PORT_Alloc(sizeof(CK_RC5_CBC_PARAMS) + ((iv) ? iv->len : 0));
865 if (rc5_cbc_params == NULL) break;
866 if (iv && iv->data && iv->len) {
867 rc5_cbc_params->pIv = ((CK_BYTE_PTR) rc5_cbc_params)
868 + sizeof(CK_RC5_CBC_PARAMS);
869 PORT_Memcpy(rc5_cbc_params->pIv,iv->data,iv->len);
870 rc5_cbc_params->ulIvLen = iv->len;
871 rc5_cbc_params->ulWordsize = iv->len/2;
872 } else {
873 rc5_cbc_params->ulWordsize = 4;
874 rc5_cbc_params->pIv = NULL;
875 rc5_cbc_params->ulIvLen = 0;
876 }
877 rc5_cbc_params->ulRounds = 16;
878 param->data = (unsigned char *) rc5_cbc_params;
879 param->len = sizeof(CK_RC5_CBC_PARAMS);
880 break;
881 case CKM_RC5_ECB:
882 rc5_params = (CK_RC5_PARAMS *)PORT_Alloc(sizeof(CK_RC5_PARAMS));
883 if (rc5_params == NULL) break;
884 if (iv && iv->data && iv->len) {
885 rc5_params->ulWordsize = iv->len/2;
886 } else {
887 rc5_params->ulWordsize = 4;
888 }
889 rc5_params->ulRounds = 16;
890 param->data = (unsigned char *) rc5_params;
891 param->len = sizeof(CK_RC5_PARAMS);
892 break;
893
894 case CKM_SEED_CBC:
895 case CKM_CAMELLIA_CBC:
896 case CKM_AES_CBC:
897 case CKM_DES_CBC:
898 case CKM_DES3_CBC:
899 case CKM_IDEA_CBC:
900 case CKM_CDMF_CBC:
901 case CKM_CAST_CBC:
902 case CKM_CAST3_CBC:
903 case CKM_CAST5_CBC:
904 case CKM_CAMELLIA_CBC_PAD:
905 case CKM_AES_CBC_PAD:
906 case CKM_DES_CBC_PAD:
907 case CKM_DES3_CBC_PAD:
908 case CKM_IDEA_CBC_PAD:
909 case CKM_CDMF_CBC_PAD:
910 case CKM_CAST_CBC_PAD:
911 case CKM_CAST3_CBC_PAD:
912 case CKM_CAST5_CBC_PAD:
913 case CKM_SKIPJACK_CBC64:
914 case CKM_SKIPJACK_ECB64:
915 case CKM_SKIPJACK_OFB64:
916 case CKM_SKIPJACK_CFB64:
917 case CKM_SKIPJACK_CFB32:
918 case CKM_SKIPJACK_CFB16:
919 case CKM_SKIPJACK_CFB8:
920 case CKM_BATON_ECB128:
921 case CKM_BATON_ECB96:
922 case CKM_BATON_CBC128:
923 case CKM_BATON_COUNTER:
924 case CKM_BATON_SHUFFLE:
925 case CKM_JUNIPER_ECB128:
926 case CKM_JUNIPER_CBC128:
927 case CKM_JUNIPER_COUNTER:
928 case CKM_JUNIPER_SHUFFLE:
929 if ((iv == NULL) || (iv->data == NULL)) break;
930 param->data = (unsigned char*)PORT_Alloc(iv->len);
931 if (param->data != NULL) {
932 PORT_Memcpy(param->data,iv->data,iv->len);
933 param->len = iv->len;
934 }
935 break;
936 /* unknown mechanism, pass IV in if it's there */
937 default:
938 if (pk11_lookup(type)->iv == 0) {
939 break;
940 }
941 if ((iv == NULL) || (iv->data == NULL)) {
942 break;
943 }
944 param->data = (unsigned char*)PORT_Alloc(iv->len);
945 if (param->data != NULL) {
946 PORT_Memcpy(param->data,iv->data,iv->len);
947 param->len = iv->len;
948 }
949 break;
950 }
951 return param;
952 }
953
954 /* These next two utilities are here to help facilitate future
955 * Dynamic Encrypt/Decrypt symetric key mechanisms, and to allow functions
956 * like SSL and S-MIME to automatically add them.
957 */
958 SECItem *
959 PK11_ParamFromIV(CK_MECHANISM_TYPE type,SECItem *iv)
960 {
961 return pk11_ParamFromIVWithLen(type, iv, 0);
962 }
963
964 unsigned char *
965 PK11_IVFromParam(CK_MECHANISM_TYPE type,SECItem *param,int *len)
966 {
967 CK_RC2_CBC_PARAMS *rc2_params;
968 CK_RC5_CBC_PARAMS *rc5_cbc_params;
969
970 *len = 0;
971 switch (type) {
972 case CKM_SEED_ECB:
973 case CKM_CAMELLIA_ECB:
974 case CKM_AES_ECB:
975 case CKM_DES_ECB:
976 case CKM_DES3_ECB:
977 case CKM_RSA_PKCS:
978 case CKM_RSA_X_509:
979 case CKM_RSA_9796:
980 case CKM_IDEA_ECB:
981 case CKM_CDMF_ECB:
982 case CKM_CAST_ECB:
983 case CKM_CAST3_ECB:
984 case CKM_CAST5_ECB:
985 case CKM_RC4:
986 return NULL;
987 case CKM_RC2_ECB:
988 return NULL;
989 case CKM_RC2_CBC:
990 case CKM_RC2_CBC_PAD:
991 rc2_params = (CK_RC2_CBC_PARAMS *)param->data;
992 *len = sizeof(rc2_params->iv);
993 return &rc2_params->iv[0];
994 case CKM_RC5_CBC:
995 case CKM_RC5_CBC_PAD:
996 rc5_cbc_params = (CK_RC5_CBC_PARAMS *) param->data;
997 *len = rc5_cbc_params->ulIvLen;
998 return rc5_cbc_params->pIv;
999 case CKM_SEED_CBC:
1000 case CKM_CAMELLIA_CBC:
1001 case CKM_AES_CBC:
1002 case CKM_DES_CBC:
1003 case CKM_DES3_CBC:
1004 case CKM_IDEA_CBC:
1005 case CKM_CDMF_CBC:
1006 case CKM_CAST_CBC:
1007 case CKM_CAST3_CBC:
1008 case CKM_CAST5_CBC:
1009 case CKM_CAMELLIA_CBC_PAD:
1010 case CKM_AES_CBC_PAD:
1011 case CKM_DES_CBC_PAD:
1012 case CKM_DES3_CBC_PAD:
1013 case CKM_IDEA_CBC_PAD:
1014 case CKM_CDMF_CBC_PAD:
1015 case CKM_CAST_CBC_PAD:
1016 case CKM_CAST3_CBC_PAD:
1017 case CKM_CAST5_CBC_PAD:
1018 case CKM_SKIPJACK_CBC64:
1019 case CKM_SKIPJACK_ECB64:
1020 case CKM_SKIPJACK_OFB64:
1021 case CKM_SKIPJACK_CFB64:
1022 case CKM_SKIPJACK_CFB32:
1023 case CKM_SKIPJACK_CFB16:
1024 case CKM_SKIPJACK_CFB8:
1025 case CKM_BATON_ECB128:
1026 case CKM_BATON_ECB96:
1027 case CKM_BATON_CBC128:
1028 case CKM_BATON_COUNTER:
1029 case CKM_BATON_SHUFFLE:
1030 case CKM_JUNIPER_ECB128:
1031 case CKM_JUNIPER_CBC128:
1032 case CKM_JUNIPER_COUNTER:
1033 case CKM_JUNIPER_SHUFFLE:
1034 break;
1035 /* unknown mechanism, pass IV in if it's there */
1036 default:
1037 break;
1038 }
1039 if (param->data) {
1040 *len = param->len;
1041 }
1042 return param->data;
1043 }
1044
1045 typedef struct sec_rc5cbcParameterStr {
1046 SECItem version;
1047 SECItem rounds;
1048 SECItem blockSizeInBits;
1049 SECItem iv;
1050 } sec_rc5cbcParameter;
1051
1052 static const SEC_ASN1Template sec_rc5ecb_parameter_template[] = {
1053 { SEC_ASN1_SEQUENCE,
1054 0, NULL, sizeof(sec_rc5cbcParameter) },
1055 { SEC_ASN1_INTEGER,
1056 offsetof(sec_rc5cbcParameter,version) },
1057 { SEC_ASN1_INTEGER,
1058 offsetof(sec_rc5cbcParameter,rounds) },
1059 { SEC_ASN1_INTEGER,
1060 offsetof(sec_rc5cbcParameter,blockSizeInBits) },
1061 { 0 }
1062 };
1063
1064 static const SEC_ASN1Template sec_rc5cbc_parameter_template[] = {
1065 { SEC_ASN1_SEQUENCE,
1066 0, NULL, sizeof(sec_rc5cbcParameter) },
1067 { SEC_ASN1_INTEGER,
1068 offsetof(sec_rc5cbcParameter,version) },
1069 { SEC_ASN1_INTEGER,
1070 offsetof(sec_rc5cbcParameter,rounds) },
1071 { SEC_ASN1_INTEGER,
1072 offsetof(sec_rc5cbcParameter,blockSizeInBits) },
1073 { SEC_ASN1_OCTET_STRING,
1074 offsetof(sec_rc5cbcParameter,iv) },
1075 { 0 }
1076 };
1077
1078 typedef struct sec_rc2cbcParameterStr {
1079 SECItem rc2ParameterVersion;
1080 SECItem iv;
1081 } sec_rc2cbcParameter;
1082
1083 static const SEC_ASN1Template sec_rc2cbc_parameter_template[] = {
1084 { SEC_ASN1_SEQUENCE,
1085 0, NULL, sizeof(sec_rc2cbcParameter) },
1086 { SEC_ASN1_INTEGER,
1087 offsetof(sec_rc2cbcParameter,rc2ParameterVersion) },
1088 { SEC_ASN1_OCTET_STRING,
1089 offsetof(sec_rc2cbcParameter,iv) },
1090 { 0 }
1091 };
1092
1093 static const SEC_ASN1Template sec_rc2ecb_parameter_template[] = {
1094 { SEC_ASN1_SEQUENCE,
1095 0, NULL, sizeof(sec_rc2cbcParameter) },
1096 { SEC_ASN1_INTEGER,
1097 offsetof(sec_rc2cbcParameter,rc2ParameterVersion) },
1098 { 0 }
1099 };
1100
1101 /* S/MIME picked id values to represent differnt keysizes */
1102 /* I do have a formula, but it ain't pretty, and it only works because you
1103 * can always match three points to a parabola:) */
1104 static unsigned char rc2_map(SECItem *version)
1105 {
1106 long x;
1107
1108 x = DER_GetInteger(version);
1109
1110 switch (x) {
1111 case 58: return 128;
1112 case 120: return 64;
1113 case 160: return 40;
1114 }
1115 return 128;
1116 }
1117
1118 static unsigned long rc2_unmap(unsigned long x)
1119 {
1120 switch (x) {
1121 case 128: return 58;
1122 case 64: return 120;
1123 case 40: return 160;
1124 }
1125 return 58;
1126 }
1127
1128
1129
1130 /* Generate a mechaism param from a type, and iv. */
1131 SECItem *
1132 PK11_ParamFromAlgid(SECAlgorithmID *algid)
1133 {
1134 CK_RC2_CBC_PARAMS * rc2_cbc_params = NULL;
1135 CK_RC2_PARAMS * rc2_ecb_params = NULL;
1136 CK_RC5_CBC_PARAMS * rc5_cbc_params = NULL;
1137 CK_RC5_PARAMS * rc5_ecb_params = NULL;
1138 PLArenaPool * arena = NULL;
1139 SECItem * mech = NULL;
1140 SECOidTag algtag;
1141 SECStatus rv;
1142 CK_MECHANISM_TYPE type;
1143 /* initialize these to prevent UMRs in the ASN1 decoder. */
1144 SECItem iv = {siBuffer, NULL, 0};
1145 sec_rc2cbcParameter rc2 = { {siBuffer, NULL, 0}, {siBuffer, NULL, 0} };
1146 sec_rc5cbcParameter rc5 = { {siBuffer, NULL, 0}, {siBuffer, NULL, 0},
1147 {siBuffer, NULL, 0}, {siBuffer, NULL, 0} };
1148
1149 algtag = SECOID_GetAlgorithmTag(algid);
1150 type = PK11_AlgtagToMechanism(algtag);
1151
1152 mech = PORT_New(SECItem);
1153 if (mech == NULL) {
1154 return NULL;
1155 }
1156 mech->type = siBuffer;
1157 mech->data = NULL;
1158 mech->len = 0;
1159
1160 arena = PORT_NewArena(1024);
1161 if (!arena) {
1162 goto loser;
1163 }
1164
1165 /* handle the complicated cases */
1166 switch (type) {
1167 case CKM_RC2_ECB:
1168 rv = SEC_ASN1DecodeItem(arena, &rc2 ,sec_rc2ecb_parameter_template,
1169 &(algid->parameters));
1170 if (rv != SECSuccess) {
1171 goto loser;
1172 }
1173 rc2_ecb_params = PORT_New(CK_RC2_PARAMS);
1174 if (rc2_ecb_params == NULL) {
1175 goto loser;
1176 }
1177 *rc2_ecb_params = rc2_map(&rc2.rc2ParameterVersion);
1178 mech->data = (unsigned char *) rc2_ecb_params;
1179 mech->len = sizeof *rc2_ecb_params;
1180 break;
1181 case CKM_RC2_CBC:
1182 case CKM_RC2_CBC_PAD:
1183 rv = SEC_ASN1DecodeItem(arena, &rc2 ,sec_rc2cbc_parameter_template,
1184 &(algid->parameters));
1185 if (rv != SECSuccess) {
1186 goto loser;
1187 }
1188 rc2_cbc_params = PORT_New(CK_RC2_CBC_PARAMS);
1189 if (rc2_cbc_params == NULL) {
1190 goto loser;
1191 }
1192 mech->data = (unsigned char *) rc2_cbc_params;
1193 mech->len = sizeof *rc2_cbc_params;
1194 rc2_cbc_params->ulEffectiveBits = rc2_map(&rc2.rc2ParameterVersion);
1195 if (rc2.iv.len != sizeof rc2_cbc_params->iv) {
1196 PORT_SetError(SEC_ERROR_INPUT_LEN);
1197 goto loser;
1198 }
1199 PORT_Memcpy(rc2_cbc_params->iv, rc2.iv.data, rc2.iv.len);
1200 break;
1201 case CKM_RC5_ECB:
1202 rv = SEC_ASN1DecodeItem(arena, &rc5 ,sec_rc5ecb_parameter_template,
1203 &(algid->parameters));
1204 if (rv != SECSuccess) {
1205 goto loser;
1206 }
1207 rc5_ecb_params = PORT_New(CK_RC5_PARAMS);
1208 if (rc5_ecb_params == NULL) {
1209 goto loser;
1210 }
1211 rc5_ecb_params->ulRounds = DER_GetInteger(&rc5.rounds);
1212 rc5_ecb_params->ulWordsize = DER_GetInteger(&rc5.blockSizeInBits)/8;
1213 mech->data = (unsigned char *) rc5_ecb_params;
1214 mech->len = sizeof *rc5_ecb_params;
1215 break;
1216 case CKM_RC5_CBC:
1217 case CKM_RC5_CBC_PAD:
1218 rv = SEC_ASN1DecodeItem(arena, &rc5 ,sec_rc5cbc_parameter_template,
1219 &(algid->parameters));
1220 if (rv != SECSuccess) {
1221 goto loser;
1222 }
1223 rc5_cbc_params = (CK_RC5_CBC_PARAMS *)
1224 PORT_Alloc(sizeof(CK_RC5_CBC_PARAMS) + rc5.iv.len);
1225 if (rc5_cbc_params == NULL) {
1226 goto loser;
1227 }
1228 mech->data = (unsigned char *) rc5_cbc_params;
1229 mech->len = sizeof *rc5_cbc_params;
1230 rc5_cbc_params->ulRounds = DER_GetInteger(&rc5.rounds);
1231 rc5_cbc_params->ulWordsize = DER_GetInteger(&rc5.blockSizeInBits)/8;
1232 rc5_cbc_params->pIv = ((CK_BYTE_PTR)rc5_cbc_params)
1233 + sizeof(CK_RC5_CBC_PARAMS);
1234 rc5_cbc_params->ulIvLen = rc5.iv.len;
1235 PORT_Memcpy(rc5_cbc_params->pIv, rc5.iv.data, rc5.iv.len);
1236 break;
1237 case CKM_PBE_MD2_DES_CBC:
1238 case CKM_PBE_MD5_DES_CBC:
1239 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:
1240 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:
1241 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:
1242 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:
1243 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:
1244 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:
1245 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:
1246 case CKM_PBE_SHA1_DES2_EDE_CBC:
1247 case CKM_PBE_SHA1_DES3_EDE_CBC:
1248 case CKM_PBE_SHA1_RC2_40_CBC:
1249 case CKM_PBE_SHA1_RC2_128_CBC:
1250 case CKM_PBE_SHA1_RC4_40:
1251 case CKM_PBE_SHA1_RC4_128:
1252 case CKM_PKCS5_PBKD2:
1253 rv = pbe_PK11AlgidToParam(algid,mech);
1254 if (rv != SECSuccess) {
1255 goto loser;
1256 }
1257 break;
1258 case CKM_RC4:
1259 case CKM_SEED_ECB:
1260 case CKM_CAMELLIA_ECB:
1261 case CKM_AES_ECB:
1262 case CKM_DES_ECB:
1263 case CKM_DES3_ECB:
1264 case CKM_IDEA_ECB:
1265 case CKM_CDMF_ECB:
1266 case CKM_CAST_ECB:
1267 case CKM_CAST3_ECB:
1268 case CKM_CAST5_ECB:
1269 break;
1270
1271 default:
1272 if (pk11_lookup(type)->iv == 0) {
1273 break;
1274 }
1275 /* FALL THROUGH */
1276 case CKM_SEED_CBC:
1277 case CKM_CAMELLIA_CBC:
1278 case CKM_AES_CBC:
1279 case CKM_DES_CBC:
1280 case CKM_DES3_CBC:
1281 case CKM_IDEA_CBC:
1282 case CKM_CDMF_CBC:
1283 case CKM_CAST_CBC:
1284 case CKM_CAST3_CBC:
1285 case CKM_CAST5_CBC:
1286 case CKM_SEED_CBC_PAD:
1287 case CKM_CAMELLIA_CBC_PAD:
1288 case CKM_AES_CBC_PAD:
1289 case CKM_DES_CBC_PAD:
1290 case CKM_DES3_CBC_PAD:
1291 case CKM_IDEA_CBC_PAD:
1292 case CKM_CDMF_CBC_PAD:
1293 case CKM_CAST_CBC_PAD:
1294 case CKM_CAST3_CBC_PAD:
1295 case CKM_CAST5_CBC_PAD:
1296 case CKM_SKIPJACK_CBC64:
1297 case CKM_SKIPJACK_ECB64:
1298 case CKM_SKIPJACK_OFB64:
1299 case CKM_SKIPJACK_CFB64:
1300 case CKM_SKIPJACK_CFB32:
1301 case CKM_SKIPJACK_CFB16:
1302 case CKM_SKIPJACK_CFB8:
1303 case CKM_BATON_ECB128:
1304 case CKM_BATON_ECB96:
1305 case CKM_BATON_CBC128:
1306 case CKM_BATON_COUNTER:
1307 case CKM_BATON_SHUFFLE:
1308 case CKM_JUNIPER_ECB128:
1309 case CKM_JUNIPER_CBC128:
1310 case CKM_JUNIPER_COUNTER:
1311 case CKM_JUNIPER_SHUFFLE:
1312 /* simple cases are simply octet string encoded IVs */
1313 rv = SEC_ASN1DecodeItem(arena, &iv,
1314 SEC_ASN1_GET(SEC_OctetStringTemplate),
1315 &(algid->parameters));
1316 if (rv != SECSuccess || iv.data == NULL) {
1317 goto loser;
1318 }
1319 /* XXX Should be some IV length sanity check here. */
1320 mech->data = (unsigned char*)PORT_Alloc(iv.len);
1321 if (mech->data == NULL) {
1322 goto loser;
1323 }
1324 PORT_Memcpy(mech->data, iv.data, iv.len);
1325 mech->len = iv.len;
1326 break;
1327 }
1328 PORT_FreeArena(arena, PR_FALSE);
1329 return mech;
1330
1331 loser:
1332 if (arena)
1333 PORT_FreeArena(arena, PR_FALSE);
1334 SECITEM_FreeItem(mech,PR_TRUE);
1335 return NULL;
1336 }
1337
1338 /*
1339 * Generate an IV for the given mechanism
1340 */
1341 static SECStatus
1342 pk11_GenIV(CK_MECHANISM_TYPE type, SECItem *iv) {
1343 int iv_size = PK11_GetIVLength(type);
1344 SECStatus rv;
1345
1346 iv->len = iv_size;
1347 if (iv_size == 0) {
1348 iv->data = NULL;
1349 return SECSuccess;
1350 }
1351
1352 iv->data = (unsigned char *) PORT_Alloc(iv_size);
1353 if (iv->data == NULL) {
1354 iv->len = 0;
1355 return SECFailure;
1356 }
1357
1358 rv = PK11_GenerateRandom(iv->data,iv->len);
1359 if (rv != SECSuccess) {
1360 PORT_Free(iv->data);
1361 iv->data = NULL; iv->len = 0;
1362 return SECFailure;
1363 }
1364 return SECSuccess;
1365 }
1366
1367
1368 /*
1369 * create a new parameter block from the passed in MECHANISM and the
1370 * key. Use Netscape's S/MIME Rules for the New param block.
1371 */
1372 SECItem *
1373 pk11_GenerateNewParamWithKeyLen(CK_MECHANISM_TYPE type, int keyLen)
1374 {
1375 CK_RC2_CBC_PARAMS *rc2_params;
1376 CK_RC2_PARAMS *rc2_ecb_params;
1377 SECItem *mech;
1378 SECItem iv;
1379 SECStatus rv;
1380
1381
1382 mech = (SECItem *) PORT_Alloc(sizeof(SECItem));
1383 if (mech == NULL) return NULL;
1384
1385 rv = SECSuccess;
1386 mech->type = siBuffer;
1387 switch (type) {
1388 case CKM_RC4:
1389 case CKM_SEED_ECB:
1390 case CKM_CAMELLIA_ECB:
1391 case CKM_AES_ECB:
1392 case CKM_DES_ECB:
1393 case CKM_DES3_ECB:
1394 case CKM_IDEA_ECB:
1395 case CKM_CDMF_ECB:
1396 case CKM_CAST_ECB:
1397 case CKM_CAST3_ECB:
1398 case CKM_CAST5_ECB:
1399 mech->data = NULL;
1400 mech->len = 0;
1401 break;
1402 case CKM_RC2_ECB:
1403 rc2_ecb_params = (CK_RC2_PARAMS *)PORT_Alloc(sizeof(CK_RC2_PARAMS));
1404 if (rc2_ecb_params == NULL) {
1405 rv = SECFailure;
1406 break;
1407 }
1408 /* NOTE PK11_GetKeyLength can return -1 if the key isn't and RC2, RC5,
1409 * or RC4 key. Of course that wouldn't happen here doing RC2:).*/
1410 *rc2_ecb_params = keyLen ? keyLen*8 : 128;
1411 mech->data = (unsigned char *) rc2_ecb_params;
1412 mech->len = sizeof(CK_RC2_PARAMS);
1413 break;
1414 case CKM_RC2_CBC:
1415 case CKM_RC2_CBC_PAD:
1416 rv = pk11_GenIV(type,&iv);
1417 if (rv != SECSuccess) {
1418 break;
1419 }
1420 rc2_params = (CK_RC2_CBC_PARAMS *)PORT_Alloc(sizeof(CK_RC2_CBC_PARAMS));
1421 if (rc2_params == NULL) {
1422 PORT_Free(iv.data);
1423 rv = SECFailure;
1424 break;
1425 }
1426 /* NOTE PK11_GetKeyLength can return -1 if the key isn't and RC2, RC5,
1427 * or RC4 key. Of course that wouldn't happen here doing RC2:).*/
1428 rc2_params->ulEffectiveBits = keyLen ? keyLen*8 : 128;
1429 if (iv.data)
1430 PORT_Memcpy(rc2_params->iv,iv.data,sizeof(rc2_params->iv));
1431 mech->data = (unsigned char *) rc2_params;
1432 mech->len = sizeof(CK_RC2_CBC_PARAMS);
1433 PORT_Free(iv.data);
1434 break;
1435 case CKM_RC5_ECB:
1436 PORT_Free(mech);
1437 return PK11_ParamFromIV(type,NULL);
1438 case CKM_RC5_CBC:
1439 case CKM_RC5_CBC_PAD:
1440 rv = pk11_GenIV(type,&iv);
1441 if (rv != SECSuccess) {
1442 break;
1443 }
1444 PORT_Free(mech);
1445 return PK11_ParamFromIV(type,&iv);
1446 default:
1447 if (pk11_lookup(type)->iv == 0) {
1448 mech->data = NULL;
1449 mech->len = 0;
1450 break;
1451 }
1452 case CKM_SEED_CBC:
1453 case CKM_CAMELLIA_CBC:
1454 case CKM_AES_CBC:
1455 case CKM_DES_CBC:
1456 case CKM_DES3_CBC:
1457 case CKM_IDEA_CBC:
1458 case CKM_CDMF_CBC:
1459 case CKM_CAST_CBC:
1460 case CKM_CAST3_CBC:
1461 case CKM_CAST5_CBC:
1462 case CKM_DES_CBC_PAD:
1463 case CKM_DES3_CBC_PAD:
1464 case CKM_IDEA_CBC_PAD:
1465 case CKM_CDMF_CBC_PAD:
1466 case CKM_CAST_CBC_PAD:
1467 case CKM_CAST3_CBC_PAD:
1468 case CKM_CAST5_CBC_PAD:
1469 case CKM_SKIPJACK_CBC64:
1470 case CKM_SKIPJACK_ECB64:
1471 case CKM_SKIPJACK_OFB64:
1472 case CKM_SKIPJACK_CFB64:
1473 case CKM_SKIPJACK_CFB32:
1474 case CKM_SKIPJACK_CFB16:
1475 case CKM_SKIPJACK_CFB8:
1476 case CKM_BATON_ECB128:
1477 case CKM_BATON_ECB96:
1478 case CKM_BATON_CBC128:
1479 case CKM_BATON_COUNTER:
1480 case CKM_BATON_SHUFFLE:
1481 case CKM_JUNIPER_ECB128:
1482 case CKM_JUNIPER_CBC128:
1483 case CKM_JUNIPER_COUNTER:
1484 case CKM_JUNIPER_SHUFFLE:
1485 rv = pk11_GenIV(type,&iv);
1486 if (rv != SECSuccess) {
1487 break;
1488 }
1489 mech->data = (unsigned char*)PORT_Alloc(iv.len);
1490 if (mech->data == NULL) {
1491 PORT_Free(iv.data);
1492 rv = SECFailure;
1493 break;
1494 }
1495 PORT_Memcpy(mech->data,iv.data,iv.len);
1496 mech->len = iv.len;
1497 PORT_Free(iv.data);
1498 break;
1499 }
1500 if (rv != SECSuccess) {
1501 SECITEM_FreeItem(mech,PR_TRUE);
1502 return NULL;
1503 }
1504 return mech;
1505
1506 }
1507
1508 SECItem *
1509 PK11_GenerateNewParam(CK_MECHANISM_TYPE type, PK11SymKey *key)
1510 {
1511 int keyLen = key ? PK11_GetKeyLength(key) : 0;
1512
1513 return pk11_GenerateNewParamWithKeyLen(type, keyLen);
1514 }
1515
1516 #define RC5_V10 0x10
1517
1518 /* turn a PKCS #11 parameter into a DER Encoded Algorithm ID */
1519 SECStatus
1520 PK11_ParamToAlgid(SECOidTag algTag, SECItem *param,
1521 PLArenaPool *arena, SECAlgorithmID *algid) {
1522 CK_RC2_CBC_PARAMS *rc2_params;
1523 sec_rc2cbcParameter rc2;
1524 CK_RC5_CBC_PARAMS *rc5_params;
1525 sec_rc5cbcParameter rc5;
1526 CK_MECHANISM_TYPE type = PK11_AlgtagToMechanism(algTag);
1527 SECItem *newParams = NULL;
1528 SECStatus rv = SECFailure;
1529 unsigned long rc2version;
1530
1531 switch (type) {
1532 case CKM_RC4:
1533 case CKM_SEED_ECB:
1534 case CKM_CAMELLIA_ECB:
1535 case CKM_AES_ECB:
1536 case CKM_DES_ECB:
1537 case CKM_DES3_ECB:
1538 case CKM_IDEA_ECB:
1539 case CKM_CDMF_ECB:
1540 case CKM_CAST_ECB:
1541 case CKM_CAST3_ECB:
1542 case CKM_CAST5_ECB:
1543 newParams = NULL;
1544 rv = SECSuccess;
1545 break;
1546 case CKM_RC2_ECB:
1547 break;
1548 case CKM_RC2_CBC:
1549 case CKM_RC2_CBC_PAD:
1550 rc2_params = (CK_RC2_CBC_PARAMS *)param->data;
1551 rc2version = rc2_unmap(rc2_params->ulEffectiveBits);
1552 if (SEC_ASN1EncodeUnsignedInteger (NULL, &(rc2.rc2ParameterVersion),
1553 rc2version) == NULL)
1554 break;
1555 rc2.iv.data = rc2_params->iv;
1556 rc2.iv.len = sizeof(rc2_params->iv);
1557 newParams = SEC_ASN1EncodeItem (NULL, NULL, &rc2,
1558 sec_rc2cbc_parameter_template);
1559 PORT_Free(rc2.rc2ParameterVersion.data);
1560 if (newParams == NULL)
1561 break;
1562 rv = SECSuccess;
1563 break;
1564
1565 case CKM_RC5_ECB: /* well not really... */
1566 break;
1567 case CKM_RC5_CBC:
1568 case CKM_RC5_CBC_PAD:
1569 rc5_params = (CK_RC5_CBC_PARAMS *)param->data;
1570 if (SEC_ASN1EncodeUnsignedInteger (NULL, &rc5.version, RC5_V10) == NULL)
1571 break;
1572 if (SEC_ASN1EncodeUnsignedInteger (NULL, &rc5.blockSizeInBits,
1573 rc5_params->ulWordsize*8) == NULL) {
1574 PORT_Free(rc5.version.data);
1575 break;
1576 }
1577 if (SEC_ASN1EncodeUnsignedInteger (NULL, &rc5.rounds,
1578 rc5_params->ulWordsize*8) == NULL) {
1579 PORT_Free(rc5.blockSizeInBits.data);
1580 PORT_Free(rc5.version.data);
1581 break;
1582 }
1583 rc5.iv.data = rc5_params->pIv;
1584 rc5.iv.len = rc5_params->ulIvLen;
1585 newParams = SEC_ASN1EncodeItem (NULL, NULL, &rc5,
1586 sec_rc5cbc_parameter_template);
1587 PORT_Free(rc5.version.data);
1588 PORT_Free(rc5.blockSizeInBits.data);
1589 PORT_Free(rc5.rounds.data);
1590 if (newParams == NULL)
1591 break;
1592 rv = SECSuccess;
1593 break;
1594 case CKM_PBE_MD2_DES_CBC:
1595 case CKM_PBE_MD5_DES_CBC:
1596 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:
1597 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:
1598 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:
1599 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:
1600 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:
1601 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:
1602 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:
1603 case CKM_PBE_SHA1_DES3_EDE_CBC:
1604 case CKM_PBE_SHA1_DES2_EDE_CBC:
1605 case CKM_PBE_SHA1_RC2_40_CBC:
1606 case CKM_PBE_SHA1_RC2_128_CBC:
1607 case CKM_PBE_SHA1_RC4_40:
1608 case CKM_PBE_SHA1_RC4_128:
1609 return PBE_PK11ParamToAlgid(algTag, param, arena, algid);
1610 default:
1611 if (pk11_lookup(type)->iv == 0) {
1612 rv = SECSuccess;
1613 newParams = NULL;
1614 break;
1615 }
1616 case CKM_SEED_CBC:
1617 case CKM_CAMELLIA_CBC:
1618 case CKM_AES_CBC:
1619 case CKM_DES_CBC:
1620 case CKM_DES3_CBC:
1621 case CKM_IDEA_CBC:
1622 case CKM_CDMF_CBC:
1623 case CKM_CAST_CBC:
1624 case CKM_CAST3_CBC:
1625 case CKM_CAST5_CBC:
1626 case CKM_DES_CBC_PAD:
1627 case CKM_DES3_CBC_PAD:
1628 case CKM_IDEA_CBC_PAD:
1629 case CKM_CDMF_CBC_PAD:
1630 case CKM_CAST_CBC_PAD:
1631 case CKM_CAST3_CBC_PAD:
1632 case CKM_CAST5_CBC_PAD:
1633 case CKM_SKIPJACK_CBC64:
1634 case CKM_SKIPJACK_ECB64:
1635 case CKM_SKIPJACK_OFB64:
1636 case CKM_SKIPJACK_CFB64:
1637 case CKM_SKIPJACK_CFB32:
1638 case CKM_SKIPJACK_CFB16:
1639 case CKM_SKIPJACK_CFB8:
1640 case CKM_BATON_ECB128:
1641 case CKM_BATON_ECB96:
1642 case CKM_BATON_CBC128:
1643 case CKM_BATON_COUNTER:
1644 case CKM_BATON_SHUFFLE:
1645 case CKM_JUNIPER_ECB128:
1646 case CKM_JUNIPER_CBC128:
1647 case CKM_JUNIPER_COUNTER:
1648 case CKM_JUNIPER_SHUFFLE:
1649 newParams = SEC_ASN1EncodeItem(NULL,NULL,param,
1650 SEC_ASN1_GET(SEC_OctetStringTemplate) );
1651 if (newParams == NULL)
1652 break;
1653 rv = SECSuccess;
1654 break;
1655 }
1656
1657 if (rv != SECSuccess) {
1658 if (newParams) SECITEM_FreeItem(newParams,PR_TRUE);
1659 return rv;
1660 }
1661
1662 rv = SECOID_SetAlgorithmID(arena, algid, algTag, newParams);
1663 SECITEM_FreeItem(newParams,PR_TRUE);
1664 return rv;
1665 }
1666
1667 /* turn an OID algorithm tag into a PKCS #11 mechanism. This allows us to
1668 * map OID's directly into the PKCS #11 mechanism we want to call. We find
1669 * this mapping in our standard OID table */
1670 CK_MECHANISM_TYPE
1671 PK11_AlgtagToMechanism(SECOidTag algTag) {
1672 SECOidData *oid = SECOID_FindOIDByTag(algTag);
1673
1674 if (oid) return (CK_MECHANISM_TYPE) oid->mechanism;
1675 return CKM_INVALID_MECHANISM;
1676 }
1677
1678 /* turn a mechanism into an oid. */
1679 SECOidTag
1680 PK11_MechanismToAlgtag(CK_MECHANISM_TYPE type) {
1681 SECOidData *oid = SECOID_FindOIDByMechanism((unsigned long)type);
1682
1683 if (oid) return oid->offset;
1684 return SEC_OID_UNKNOWN;
1685 }
1686
1687 /* Determine appropriate blocking mechanism, used when wrapping private keys
1688 * which require PKCS padding. If the mechanism does not map to a padding
1689 * mechanism, we simply return the mechanism.
1690 */
1691 CK_MECHANISM_TYPE
1692 PK11_GetPadMechanism(CK_MECHANISM_TYPE type) {
1693 switch(type) {
1694 case CKM_SEED_CBC:
1695 return CKM_SEED_CBC_PAD;
1696 case CKM_CAMELLIA_CBC:
1697 return CKM_CAMELLIA_CBC_PAD;
1698 case CKM_AES_CBC:
1699 return CKM_AES_CBC_PAD;
1700 case CKM_DES_CBC:
1701 return CKM_DES_CBC_PAD;
1702 case CKM_DES3_CBC:
1703 return CKM_DES3_CBC_PAD;
1704 case CKM_RC2_CBC:
1705 return CKM_RC2_CBC_PAD;
1706 case CKM_CDMF_CBC:
1707 return CKM_CDMF_CBC_PAD;
1708 case CKM_CAST_CBC:
1709 return CKM_CAST_CBC_PAD;
1710 case CKM_CAST3_CBC:
1711 return CKM_CAST3_CBC_PAD;
1712 case CKM_CAST5_CBC:
1713 return CKM_CAST5_CBC_PAD;
1714 case CKM_RC5_CBC:
1715 return CKM_RC5_CBC_PAD;
1716 case CKM_IDEA_CBC:
1717 return CKM_IDEA_CBC_PAD;
1718 default:
1719 break;
1720 }
1721
1722 return type;
1723 }
1724
1725 static PRBool
1726 pk11_isAllZero(unsigned char *data,int len) {
1727 while (len--) {
1728 if (*data++) {
1729 return PR_FALSE;
1730 }
1731 }
1732 return PR_TRUE;
1733 }
1734
1735 CK_RV
1736 PK11_MapPBEMechanismToCryptoMechanism(CK_MECHANISM_PTR pPBEMechanism,
1737 CK_MECHANISM_PTR pCryptoMechanism,
1738 SECItem *pbe_pwd, PRBool faulty3DES)
1739 {
1740 int iv_len = 0;
1741 CK_PBE_PARAMS_PTR pPBEparams;
1742 CK_RC2_CBC_PARAMS_PTR rc2_params;
1743 CK_ULONG rc2_key_len;
1744
1745 if((pPBEMechanism == CK_NULL_PTR) || (pCryptoMechanism == CK_NULL_PTR)) {
1746 return CKR_HOST_MEMORY;
1747 }
1748
1749 /* pkcs5 v2 cannot be supported by this interface.
1750 * use PK11_GetPBECryptoMechanism instead.
1751 */
1752 if ((pPBEMechanism->mechanism == CKM_INVALID_MECHANISM) ||
1753 (pPBEMechanism->mechanism == CKM_PKCS5_PBKD2)) {
1754 return CKR_MECHANISM_INVALID;
1755 }
1756
1757 pPBEparams = (CK_PBE_PARAMS_PTR)pPBEMechanism->pParameter;
1758 iv_len = PK11_GetIVLength(pPBEMechanism->mechanism);
1759
1760 if (iv_len) {
1761 if (pk11_isAllZero(pPBEparams->pInitVector,iv_len)) {
1762 SECItem param;
1763 PK11SymKey *symKey;
1764 PK11SlotInfo *intSlot = PK11_GetInternalSlot();
1765
1766 if (intSlot == NULL) {
1767 return CKR_DEVICE_ERROR;
1768 }
1769
1770 param.data = pPBEMechanism->pParameter;
1771 param.len = pPBEMechanism->ulParameterLen;
1772
1773 symKey = PK11_RawPBEKeyGen(intSlot,
1774 pPBEMechanism->mechanism, &param, pbe_pwd, faulty3DES, NULL);
1775 PK11_FreeSlot(intSlot);
1776 if (symKey== NULL) {
1777 return CKR_DEVICE_ERROR; /* sigh */
1778 }
1779 PK11_FreeSymKey(symKey);
1780 }
1781 }
1782
1783 switch(pPBEMechanism->mechanism) {
1784 case CKM_PBE_MD2_DES_CBC:
1785 case CKM_PBE_MD5_DES_CBC:
1786 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:
1787 pCryptoMechanism->mechanism = CKM_DES_CBC;
1788 goto have_crypto_mechanism;
1789 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:
1790 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:
1791 case CKM_PBE_SHA1_DES3_EDE_CBC:
1792 case CKM_PBE_SHA1_DES2_EDE_CBC:
1793 pCryptoMechanism->mechanism = CKM_DES3_CBC;
1794 have_crypto_mechanism:
1795 pCryptoMechanism->pParameter = PORT_Alloc(iv_len);
1796 pCryptoMechanism->ulParameterLen = (CK_ULONG)iv_len;
1797 if(pCryptoMechanism->pParameter == NULL) {
1798 return CKR_HOST_MEMORY;
1799 }
1800 PORT_Memcpy((unsigned char *)(pCryptoMechanism->pParameter),
1801 (unsigned char *)(pPBEparams->pInitVector),
1802 iv_len);
1803 break;
1804 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:
1805 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:
1806 case CKM_PBE_SHA1_RC4_40:
1807 case CKM_PBE_SHA1_RC4_128:
1808 pCryptoMechanism->mechanism = CKM_RC4;
1809 pCryptoMechanism->ulParameterLen = 0;
1810 pCryptoMechanism->pParameter = CK_NULL_PTR;
1811 break;
1812 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:
1813 case CKM_PBE_SHA1_RC2_40_CBC:
1814 rc2_key_len = 40;
1815 goto have_key_len;
1816 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:
1817 rc2_key_len = 128;
1818 have_key_len:
1819 pCryptoMechanism->mechanism = CKM_RC2_CBC;
1820 pCryptoMechanism->ulParameterLen = (CK_ULONG)
1821 sizeof(CK_RC2_CBC_PARAMS);
1822 pCryptoMechanism->pParameter = (CK_RC2_CBC_PARAMS_PTR)
1823 PORT_ZAlloc(sizeof(CK_RC2_CBC_PARAMS));
1824 if(pCryptoMechanism->pParameter == NULL) {
1825 return CKR_HOST_MEMORY;
1826 }
1827 rc2_params = (CK_RC2_CBC_PARAMS_PTR)pCryptoMechanism->pParameter;
1828 PORT_Memcpy((unsigned char *)rc2_params->iv,
1829 (unsigned char *)pPBEparams->pInitVector,
1830 iv_len);
1831 rc2_params->ulEffectiveBits = rc2_key_len;
1832 break;
1833 default:
1834 return CKR_MECHANISM_INVALID;
1835 }
1836
1837 return CKR_OK;
1838 }
1839
1840 /* Make a Key type to an appropriate signing/verification mechanism */
1841 CK_MECHANISM_TYPE
1842 PK11_MapSignKeyType(KeyType keyType)
1843 {
1844 switch (keyType) {
1845 case rsaKey:
1846 return CKM_RSA_PKCS;
1847 case fortezzaKey:
1848 case dsaKey:
1849 return CKM_DSA;
1850 case ecKey:
1851 return CKM_ECDSA;
1852 case dhKey:
1853 default:
1854 break;
1855 }
1856 return CKM_INVALID_MECHANISM;
1857 }
1858
1859 CK_MECHANISM_TYPE
1860 pk11_mapWrapKeyType(KeyType keyType)
1861 {
1862 switch (keyType) {
1863 case rsaKey:
1864 return CKM_RSA_PKCS;
1865 /* Add fortezza?? */
1866 default:
1867 break;
1868 }
1869 return CKM_INVALID_MECHANISM;
1870 }
1871
1872 SECOidTag
1873 PK11_FortezzaMapSig(SECOidTag algTag)
1874 {
1875 switch (algTag) {
1876 case SEC_OID_MISSI_KEA_DSS:
1877 case SEC_OID_MISSI_DSS:
1878 case SEC_OID_MISSI_DSS_OLD:
1879 case SEC_OID_MISSI_KEA_DSS_OLD:
1880 case SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST:
1881 return SEC_OID_ANSIX9_DSA_SIGNATURE;
1882 default:
1883 break;
1884 }
1885 return algTag;
1886 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial