Coverage Report

Created: 2024-11-21 07:03

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