mozilla/security/nss/lib/pk11wrap/pk11mech.c - Issue 14249009: Change the NSS and NSPR source tree to the new directory structure to be

Side by Side Diff: mozilla/security/nss/lib/pk11wrap/pk11mech.c

Issue 14249009: Change the NSS and NSPR source tree to the new directory structure to be (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/nss/

Patch Set: Created 7 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
	(Empty)
1 /* This Source Code Form is subject to the terms of the Mozilla Public

2 * License, v. 2.0. If a copy of the MPL was not distributed with this

3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

4 /*

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, oldTableSizesizeof(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 key type needed for the given mechanism

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_MECHANISM_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_TLS_MASTER_KEY_DERIVE_DH:

378 case CKM_TLS_KEY_AND_MAC_DERIVE:

379 case CKM_SHA_1_HMAC:

380 case CKM_SHA_1_HMAC_GENERAL:

381 case CKM_SHA224_HMAC:

382 case CKM_SHA224_HMAC_GENERAL:

383 case CKM_SHA256_HMAC:

384 case CKM_SHA256_HMAC_GENERAL:

385 case CKM_SHA384_HMAC:

386 case CKM_SHA384_HMAC_GENERAL:

387 case CKM_SHA512_HMAC:

388 case CKM_SHA512_HMAC_GENERAL:

389 case CKM_MD2_HMAC:

390 case CKM_MD2_HMAC_GENERAL:

391 case CKM_MD5_HMAC:

392 case CKM_MD5_HMAC_GENERAL:

393 case CKM_TLS_PRF_GENERAL:

394 return CKK_GENERIC_SECRET;

395 default:

396 return pk11_lookup(type)->keyType;

397 }

398 }

399

400 /*

401 * Get the Key Gen Mechanism needed for the given

402 * crypto mechanism

403 */

404 CK_MECHANISM_TYPE

405 PK11_GetKeyGen(CK_MECHANISM_TYPE type)

406 {

407 return PK11_GetKeyGenWithSize(type, 0);

408 }

409

410 CK_MECHANISM_TYPE

411 PK11_GetKeyGenWithSize(CK_MECHANISM_TYPE type, int size)

412 {

413 switch (type) {

414 case CKM_SEED_ECB:

415 case CKM_SEED_CBC:

416 case CKM_SEED_MAC:

417 case CKM_SEED_MAC_GENERAL:

418 case CKM_SEED_CBC_PAD:

419 case CKM_SEED_KEY_GEN:

420 return CKM_SEED_KEY_GEN;

421 case CKM_CAMELLIA_ECB:

422 case CKM_CAMELLIA_CBC:

423 case CKM_CAMELLIA_MAC:

424 case CKM_CAMELLIA_MAC_GENERAL:

425 case CKM_CAMELLIA_CBC_PAD:

426 case CKM_CAMELLIA_KEY_GEN:

427 return CKM_CAMELLIA_KEY_GEN;

428 case CKM_AES_ECB:

429 case CKM_AES_CBC:

430 case CKM_AES_MAC:

431 case CKM_AES_MAC_GENERAL:

432 case CKM_AES_CBC_PAD:

433 case CKM_AES_KEY_GEN:

434 return CKM_AES_KEY_GEN;

435 case CKM_DES_ECB:

436 case CKM_DES_CBC:

437 case CKM_DES_MAC:

438 case CKM_DES_MAC_GENERAL:

439 case CKM_KEY_WRAP_LYNKS:

440 case CKM_DES_CBC_PAD:

441 case CKM_DES_KEY_GEN:

442 return CKM_DES_KEY_GEN;

443 case CKM_DES3_ECB:

444 case CKM_DES3_CBC:

445 case CKM_DES3_MAC:

446 case CKM_DES3_MAC_GENERAL:

447 case CKM_DES3_CBC_PAD:

448 return (size == 16) ? CKM_DES2_KEY_GEN : CKM_DES3_KEY_GEN;

449 case CKM_DES3_KEY_GEN:

450 return CKM_DES3_KEY_GEN;

451 case CKM_DES2_KEY_GEN:

452 return CKM_DES2_KEY_GEN;

453 case CKM_CDMF_ECB:

454 case CKM_CDMF_CBC:

455 case CKM_CDMF_MAC:

456 case CKM_CDMF_MAC_GENERAL:

457 case CKM_CDMF_CBC_PAD:

458 case CKM_CDMF_KEY_GEN:

459 return CKM_CDMF_KEY_GEN;

460 case CKM_RC2_ECB:

461 case CKM_RC2_CBC:

462 case CKM_RC2_MAC:

463 case CKM_RC2_MAC_GENERAL:

464 case CKM_RC2_CBC_PAD:

465 case CKM_RC2_KEY_GEN:

466 return CKM_RC2_KEY_GEN;

467 case CKM_RC4:

468 case CKM_RC4_KEY_GEN:

469 return CKM_RC4_KEY_GEN;

470 case CKM_RC5_ECB:

471 case CKM_RC5_CBC:

472 case CKM_RC5_MAC:

473 case CKM_RC5_MAC_GENERAL:

474 case CKM_RC5_CBC_PAD:

475 case CKM_RC5_KEY_GEN:

476 return CKM_RC5_KEY_GEN;

477 case CKM_SKIPJACK_CBC64:

478 case CKM_SKIPJACK_ECB64:

479 case CKM_SKIPJACK_OFB64:

480 case CKM_SKIPJACK_CFB64:

481 case CKM_SKIPJACK_CFB32:

482 case CKM_SKIPJACK_CFB16:

483 case CKM_SKIPJACK_CFB8:

484 case CKM_SKIPJACK_WRAP:

485 case CKM_SKIPJACK_KEY_GEN:

486 return CKM_SKIPJACK_KEY_GEN;

487 case CKM_BATON_ECB128:

488 case CKM_BATON_ECB96:

489 case CKM_BATON_CBC128:

490 case CKM_BATON_COUNTER:

491 case CKM_BATON_SHUFFLE:

492 case CKM_BATON_WRAP:

493 case CKM_BATON_KEY_GEN:

494 return CKM_BATON_KEY_GEN;

495 case CKM_JUNIPER_ECB128:

496 case CKM_JUNIPER_CBC128:

497 case CKM_JUNIPER_COUNTER:

498 case CKM_JUNIPER_SHUFFLE:

499 case CKM_JUNIPER_WRAP:

500 case CKM_JUNIPER_KEY_GEN:

501 return CKM_JUNIPER_KEY_GEN;

502 case CKM_IDEA_CBC:

503 case CKM_IDEA_ECB:

504 case CKM_IDEA_MAC:

505 case CKM_IDEA_MAC_GENERAL:

506 case CKM_IDEA_CBC_PAD:

507 case CKM_IDEA_KEY_GEN:

508 return CKM_IDEA_KEY_GEN;

509 case CKM_CAST_ECB:

510 case CKM_CAST_CBC:

511 case CKM_CAST_MAC:

512 case CKM_CAST_MAC_GENERAL:

513 case CKM_CAST_CBC_PAD:

514 case CKM_CAST_KEY_GEN:

515 return CKM_CAST_KEY_GEN;

516 case CKM_CAST3_ECB:

517 case CKM_CAST3_CBC:

518 case CKM_CAST3_MAC:

519 case CKM_CAST3_MAC_GENERAL:

520 case CKM_CAST3_CBC_PAD:

521 case CKM_CAST3_KEY_GEN:

522 return CKM_CAST3_KEY_GEN;

523 case CKM_CAST5_ECB:

524 case CKM_CAST5_CBC:

525 case CKM_CAST5_MAC:

526 case CKM_CAST5_MAC_GENERAL:

527 case CKM_CAST5_CBC_PAD:

528 case CKM_CAST5_KEY_GEN:

529 return CKM_CAST5_KEY_GEN;

530 case CKM_RSA_PKCS:

531 case CKM_RSA_9796:

532 case CKM_RSA_X_509:

533 case CKM_MD2_RSA_PKCS:

534 case CKM_MD5_RSA_PKCS:

535 case CKM_SHA1_RSA_PKCS:

536 case CKM_SHA224_RSA_PKCS:

537 case CKM_SHA256_RSA_PKCS:

538 case CKM_SHA384_RSA_PKCS:

539 case CKM_SHA512_RSA_PKCS:

540 case CKM_KEY_WRAP_SET_OAEP:

541 case CKM_RSA_PKCS_KEY_PAIR_GEN:

542 return CKM_RSA_PKCS_KEY_PAIR_GEN;

543 case CKM_RSA_X9_31_KEY_PAIR_GEN:

544 return CKM_RSA_X9_31_KEY_PAIR_GEN;

545 case CKM_DSA:

546 case CKM_DSA_SHA1:

547 case CKM_DSA_KEY_PAIR_GEN:

548 return CKM_DSA_KEY_PAIR_GEN;

549 case CKM_DH_PKCS_DERIVE:

550 case CKM_DH_PKCS_KEY_PAIR_GEN:

551 return CKM_DH_PKCS_KEY_PAIR_GEN;

552 case CKM_KEA_KEY_DERIVE:

553 case CKM_KEA_KEY_PAIR_GEN:

554 return CKM_KEA_KEY_PAIR_GEN;

555 case CKM_ECDSA:

556 case CKM_ECDSA_SHA1:

557 case CKM_EC_KEY_PAIR_GEN: /* aka CKM_ECDSA_KEY_PAIR_GEN */

558 case CKM_ECDH1_DERIVE:

559 return CKM_EC_KEY_PAIR_GEN;

560 case CKM_SSL3_PRE_MASTER_KEY_GEN:

561 case CKM_SSL3_MASTER_KEY_DERIVE:

562 case CKM_SSL3_KEY_AND_MAC_DERIVE:

563 case CKM_SSL3_SHA1_MAC:

564 case CKM_SSL3_MD5_MAC:

565 case CKM_TLS_MASTER_KEY_DERIVE:

566 case CKM_TLS_KEY_AND_MAC_DERIVE:

567 return CKM_SSL3_PRE_MASTER_KEY_GEN;

568 case CKM_SHA_1_HMAC:

569 case CKM_SHA_1_HMAC_GENERAL:

570 case CKM_SHA224_HMAC:

571 case CKM_SHA224_HMAC_GENERAL:

572 case CKM_SHA256_HMAC:

573 case CKM_SHA256_HMAC_GENERAL:

574 case CKM_SHA384_HMAC:

575 case CKM_SHA384_HMAC_GENERAL:

576 case CKM_SHA512_HMAC:

577 case CKM_SHA512_HMAC_GENERAL:

578 case CKM_MD2_HMAC:

579 case CKM_MD2_HMAC_GENERAL:

580 case CKM_MD5_HMAC:

581 case CKM_MD5_HMAC_GENERAL:

582 case CKM_TLS_PRF_GENERAL:

583 case CKM_GENERIC_SECRET_KEY_GEN:

584 return CKM_GENERIC_SECRET_KEY_GEN;

585 case CKM_PBE_MD2_DES_CBC:

586 case CKM_PBE_MD5_DES_CBC:

587 case CKM_PBA_SHA1_WITH_SHA1_HMAC:

588 case CKM_NETSCAPE_PBE_SHA1_HMAC_KEY_GEN:

589 case CKM_NETSCAPE_PBE_MD5_HMAC_KEY_GEN:

590 case CKM_NETSCAPE_PBE_MD2_HMAC_KEY_GEN:

591 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

592 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

593 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

594 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

595 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

596 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

597 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

598 case CKM_PBE_SHA1_RC2_40_CBC:

599 case CKM_PBE_SHA1_RC2_128_CBC:

600 case CKM_PBE_SHA1_RC4_40:

601 case CKM_PBE_SHA1_RC4_128:

602 case CKM_PBE_SHA1_DES3_EDE_CBC:

603 case CKM_PBE_SHA1_DES2_EDE_CBC:

604 case CKM_PKCS5_PBKD2:

605 return type;

606 default:

607 return pk11_lookup(type)->keyGen;

608 }

609 }

610

611 /*

612 * get the mechanism block size

613 */

614 int

615 PK11_GetBlockSize(CK_MECHANISM_TYPE type,SECItem *params)

616 {

617 CK_RC5_PARAMS *rc5_params;

618 CK_RC5_CBC_PARAMS *rc5_cbc_params;

619 switch (type) {

620 case CKM_RC5_ECB:

621 if ((params) && (params->data)) {

622 rc5_params = (CK_RC5_PARAMS *) params->data;

623 return (rc5_params->ulWordsize)*2;

624 }

625 return 8;

626 case CKM_RC5_CBC:

627 case CKM_RC5_CBC_PAD:

628 if ((params) && (params->data)) {

629 rc5_cbc_params = (CK_RC5_CBC_PARAMS *) params->data;

630 return (rc5_cbc_params->ulWordsize)*2;

631 }

632 return 8;

633 case CKM_DES_ECB:

634 case CKM_DES3_ECB:

635 case CKM_RC2_ECB:

636 case CKM_IDEA_ECB:

637 case CKM_CAST_ECB:

638 case CKM_CAST3_ECB:

639 case CKM_CAST5_ECB:

640 case CKM_RC2_CBC:

641 case CKM_SKIPJACK_CBC64:

642 case CKM_SKIPJACK_ECB64:

643 case CKM_SKIPJACK_OFB64:

644 case CKM_SKIPJACK_CFB64:

645 case CKM_DES_CBC:

646 case CKM_DES3_CBC:

647 case CKM_IDEA_CBC:

648 case CKM_CAST_CBC:

649 case CKM_CAST3_CBC:

650 case CKM_CAST5_CBC:

651 case CKM_DES_CBC_PAD:

652 case CKM_DES3_CBC_PAD:

653 case CKM_RC2_CBC_PAD:

654 case CKM_IDEA_CBC_PAD:

655 case CKM_CAST_CBC_PAD:

656 case CKM_CAST3_CBC_PAD:

657 case CKM_CAST5_CBC_PAD:

658 case CKM_PBE_MD2_DES_CBC:

659 case CKM_PBE_MD5_DES_CBC:

660 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

661 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

662 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

663 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

664 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

665 case CKM_PBE_SHA1_RC2_40_CBC:

666 case CKM_PBE_SHA1_RC2_128_CBC:

667 case CKM_PBE_SHA1_DES3_EDE_CBC:

668 case CKM_PBE_SHA1_DES2_EDE_CBC:

669 return 8;

670 case CKM_SKIPJACK_CFB32:

671 case CKM_SKIPJACK_CFB16:

672 case CKM_SKIPJACK_CFB8:

673 return 4;

674 case CKM_SEED_ECB:

675 case CKM_SEED_CBC:

676 case CKM_SEED_CBC_PAD:

677 case CKM_CAMELLIA_ECB:

678 case CKM_CAMELLIA_CBC:

679 case CKM_CAMELLIA_CBC_PAD:

680 case CKM_AES_ECB:

681 case CKM_AES_CBC:

682 case CKM_AES_CBC_PAD:

683 case CKM_BATON_ECB128:

684 case CKM_BATON_CBC128:

685 case CKM_BATON_COUNTER:

686 case CKM_BATON_SHUFFLE:

687 case CKM_JUNIPER_ECB128:

688 case CKM_JUNIPER_CBC128:

689 case CKM_JUNIPER_COUNTER:

690 case CKM_JUNIPER_SHUFFLE:

691 return 16;

692 case CKM_BATON_ECB96:

693 return 12;

694 case CKM_RC4:

695 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

696 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

697 case CKM_PBE_SHA1_RC4_40:

698 case CKM_PBE_SHA1_RC4_128:

699 return 0;

700 case CKM_RSA_PKCS:

701 case CKM_RSA_9796:

702 case CKM_RSA_X_509:

703 /actually it's the modulus length of the key!/

704 return -1; /* failure */

705 default:

706 return pk11_lookup(type)->blockSize;

707 }

708 }

709

710 /*

711 * get the iv length

712 */

713 int

714 PK11_GetIVLength(CK_MECHANISM_TYPE type)

715 {

716 switch (type) {

717 case CKM_SEED_ECB:

718 case CKM_CAMELLIA_ECB:

719 case CKM_AES_ECB:

720 case CKM_DES_ECB:

721 case CKM_DES3_ECB:

722 case CKM_RC2_ECB:

723 case CKM_IDEA_ECB:

724 case CKM_SKIPJACK_WRAP:

725 case CKM_BATON_WRAP:

726 case CKM_RC5_ECB:

727 case CKM_CAST_ECB:

728 case CKM_CAST3_ECB:

729 case CKM_CAST5_ECB:

730 return 0;

731 case CKM_RC2_CBC:

732 case CKM_DES_CBC:

733 case CKM_DES3_CBC:

734 case CKM_IDEA_CBC:

735 case CKM_PBE_MD2_DES_CBC:

736 case CKM_PBE_MD5_DES_CBC:

737 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

738 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

739 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

740 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

741 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

742 case CKM_PBE_SHA1_RC2_40_CBC:

743 case CKM_PBE_SHA1_RC2_128_CBC:

744 case CKM_PBE_SHA1_DES3_EDE_CBC:

745 case CKM_PBE_SHA1_DES2_EDE_CBC:

746 case CKM_RC5_CBC:

747 case CKM_CAST_CBC:

748 case CKM_CAST3_CBC:

749 case CKM_CAST5_CBC:

750 case CKM_RC2_CBC_PAD:

751 case CKM_DES_CBC_PAD:

752 case CKM_DES3_CBC_PAD:

753 case CKM_IDEA_CBC_PAD:

754 case CKM_RC5_CBC_PAD:

755 case CKM_CAST_CBC_PAD:

756 case CKM_CAST3_CBC_PAD:

757 case CKM_CAST5_CBC_PAD:

758 return 8;

759 case CKM_SEED_CBC:

760 case CKM_SEED_CBC_PAD:

761 case CKM_CAMELLIA_CBC:

762 case CKM_CAMELLIA_CBC_PAD:

763 case CKM_AES_CBC:

764 case CKM_AES_CBC_PAD:

765 return 16;

766 case CKM_SKIPJACK_CBC64:

767 case CKM_SKIPJACK_ECB64:

768 case CKM_SKIPJACK_OFB64:

769 case CKM_SKIPJACK_CFB64:

770 case CKM_SKIPJACK_CFB32:

771 case CKM_SKIPJACK_CFB16:

772 case CKM_SKIPJACK_CFB8:

773 case CKM_BATON_ECB128:

774 case CKM_BATON_ECB96:

775 case CKM_BATON_CBC128:

776 case CKM_BATON_COUNTER:

777 case CKM_BATON_SHUFFLE:

778 case CKM_JUNIPER_ECB128:

779 case CKM_JUNIPER_CBC128:

780 case CKM_JUNIPER_COUNTER:

781 case CKM_JUNIPER_SHUFFLE:

782 return 24;

783 case CKM_RC4:

784 case CKM_RSA_PKCS:

785 case CKM_RSA_9796:

786 case CKM_RSA_X_509:

787 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

788 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

789 case CKM_PBE_SHA1_RC4_40:

790 case CKM_PBE_SHA1_RC4_128:

791 return 0;

792 default:

793 return pk11_lookup(type)->iv;

794 }

795 }

796

797

798 /* These next two utilities are here to help facilitate future

799 * Dynamic Encrypt/Decrypt symetric key mechanisms, and to allow functions

800 * like SSL and S-MIME to automatically add them.

801 */

802 SECItem *

803 pk11_ParamFromIVWithLen(CK_MECHANISM_TYPE type, SECItem *iv, int keyLen)

804 {

805 CK_RC2_CBC_PARAMS *rc2_params = NULL;

806 CK_RC2_PARAMS *rc2_ecb_params = NULL;

807 CK_RC5_PARAMS *rc5_params = NULL;

808 CK_RC5_CBC_PARAMS *rc5_cbc_params = NULL;

809 SECItem *param;

810

811 param = (SECItem *)PORT_Alloc(sizeof(SECItem));

812 if (param == NULL) return NULL;

813 param->data = NULL;

814 param->len = 0;

815 param->type = 0;

816 switch (type) {

817 case CKM_SEED_ECB:

818 case CKM_CAMELLIA_ECB:

819 case CKM_AES_ECB:

820 case CKM_DES_ECB:

821 case CKM_DES3_ECB:

822 case CKM_RSA_PKCS:

823 case CKM_RSA_X_509:

824 case CKM_RSA_9796:

825 case CKM_IDEA_ECB:

826 case CKM_CDMF_ECB:

827 case CKM_CAST_ECB:

828 case CKM_CAST3_ECB:

829 case CKM_CAST5_ECB:

830 case CKM_RC4:

831 break;

832 case CKM_RC2_ECB:

833 rc2_ecb_params = (CK_RC2_PARAMS *)PORT_Alloc(sizeof(CK_RC2_PARAMS));

834 if (rc2_ecb_params == NULL) break;

835 /* Maybe we should pass the key size in too to get this value? */

836 rc2_ecb_params = keyLen ? keyLen8 : 128;

837 param->data = (unsigned char *) rc2_ecb_params;

838 param->len = sizeof(CK_RC2_PARAMS);

839 break;

840 case CKM_RC2_CBC:

841 case CKM_RC2_CBC_PAD:

842 rc2_params = (CK_RC2_CBC_PARAMS *)PORT_Alloc(sizeof(CK_RC2_CBC_PARAMS));

843 if (rc2_params == NULL) break;

844 /* Maybe we should pass the key size in too to get this value? */

845 rc2_params->ulEffectiveBits = keyLen ? keyLen*8 : 128;

846 if (iv && iv->data)

847 PORT_Memcpy(rc2_params->iv,iv->data,sizeof(rc2_params->iv));

848 param->data = (unsigned char *) rc2_params;

849 param->len = sizeof(CK_RC2_CBC_PARAMS);

850 break;

851 case CKM_RC5_CBC:

852 case CKM_RC5_CBC_PAD:

853 rc5_cbc_params = (CK_RC5_CBC_PARAMS *)

854 PORT_Alloc(sizeof(CK_RC5_CBC_PARAMS) + ((iv) ? iv->len : 0));

855 if (rc5_cbc_params == NULL) break;

856 if (iv && iv->data && iv->len) {

857 rc5_cbc_params->pIv = ((CK_BYTE_PTR) rc5_cbc_params)

858 + sizeof(CK_RC5_CBC_PARAMS);

859 PORT_Memcpy(rc5_cbc_params->pIv,iv->data,iv->len);

860 rc5_cbc_params->ulIvLen = iv->len;

861 rc5_cbc_params->ulWordsize = iv->len/2;

862 } else {

863 rc5_cbc_params->ulWordsize = 4;

864 rc5_cbc_params->pIv = NULL;

865 rc5_cbc_params->ulIvLen = 0;

866 }

867 rc5_cbc_params->ulRounds = 16;

868 param->data = (unsigned char *) rc5_cbc_params;

869 param->len = sizeof(CK_RC5_CBC_PARAMS);

870 break;

871 case CKM_RC5_ECB:

872 rc5_params = (CK_RC5_PARAMS *)PORT_Alloc(sizeof(CK_RC5_PARAMS));

873 if (rc5_params == NULL) break;

874 if (iv && iv->data && iv->len) {

875 rc5_params->ulWordsize = iv->len/2;

876 } else {

877 rc5_params->ulWordsize = 4;

878 }

879 rc5_params->ulRounds = 16;

880 param->data = (unsigned char *) rc5_params;

881 param->len = sizeof(CK_RC5_PARAMS);

882 break;

883

884 case CKM_SEED_CBC:

885 case CKM_CAMELLIA_CBC:

886 case CKM_AES_CBC:

887 case CKM_DES_CBC:

888 case CKM_DES3_CBC:

889 case CKM_IDEA_CBC:

890 case CKM_CDMF_CBC:

891 case CKM_CAST_CBC:

892 case CKM_CAST3_CBC:

893 case CKM_CAST5_CBC:

894 case CKM_CAMELLIA_CBC_PAD:

895 case CKM_AES_CBC_PAD:

896 case CKM_DES_CBC_PAD:

897 case CKM_DES3_CBC_PAD:

898 case CKM_IDEA_CBC_PAD:

899 case CKM_CDMF_CBC_PAD:

900 case CKM_CAST_CBC_PAD:

901 case CKM_CAST3_CBC_PAD:

902 case CKM_CAST5_CBC_PAD:

903 case CKM_SKIPJACK_CBC64:

904 case CKM_SKIPJACK_ECB64:

905 case CKM_SKIPJACK_OFB64:

906 case CKM_SKIPJACK_CFB64:

907 case CKM_SKIPJACK_CFB32:

908 case CKM_SKIPJACK_CFB16:

909 case CKM_SKIPJACK_CFB8:

910 case CKM_BATON_ECB128:

911 case CKM_BATON_ECB96:

912 case CKM_BATON_CBC128:

913 case CKM_BATON_COUNTER:

914 case CKM_BATON_SHUFFLE:

915 case CKM_JUNIPER_ECB128:

916 case CKM_JUNIPER_CBC128:

917 case CKM_JUNIPER_COUNTER:

918 case CKM_JUNIPER_SHUFFLE:

919 if ((iv == NULL) \|\| (iv->data == NULL)) break;

920 param->data = (unsigned char*)PORT_Alloc(iv->len);

921 if (param->data != NULL) {

922 PORT_Memcpy(param->data,iv->data,iv->len);

923 param->len = iv->len;

924 }

925 break;

926 /* unknown mechanism, pass IV in if it's there */

927 default:

928 if (pk11_lookup(type)->iv == 0) {

929 break;

930 }

931 if ((iv == NULL) \|\| (iv->data == NULL)) {

932 break;

933 }

934 param->data = (unsigned char*)PORT_Alloc(iv->len);

935 if (param->data != NULL) {

936 PORT_Memcpy(param->data,iv->data,iv->len);

937 param->len = iv->len;

938 }

939 break;

940 }

941 return param;

942 }

943

944 /* These next two utilities are here to help facilitate future

945 * Dynamic Encrypt/Decrypt symetric key mechanisms, and to allow functions

946 * like SSL and S-MIME to automatically add them.

947 */

948 SECItem *

949 PK11_ParamFromIV(CK_MECHANISM_TYPE type,SECItem *iv)

950 {

951 return pk11_ParamFromIVWithLen(type, iv, 0);

952 }

953

954 unsigned char *

955 PK11_IVFromParam(CK_MECHANISM_TYPE type,SECItem param,int len)

956 {

957 CK_RC2_CBC_PARAMS *rc2_params;

958 CK_RC5_CBC_PARAMS *rc5_cbc_params;

959

960 *len = 0;

961 switch (type) {

962 case CKM_SEED_ECB:

963 case CKM_CAMELLIA_ECB:

964 case CKM_AES_ECB:

965 case CKM_DES_ECB:

966 case CKM_DES3_ECB:

967 case CKM_RSA_PKCS:

968 case CKM_RSA_X_509:

969 case CKM_RSA_9796:

970 case CKM_IDEA_ECB:

971 case CKM_CDMF_ECB:

972 case CKM_CAST_ECB:

973 case CKM_CAST3_ECB:

974 case CKM_CAST5_ECB:

975 case CKM_RC4:

976 return NULL;

977 case CKM_RC2_ECB:

978 return NULL;

979 case CKM_RC2_CBC:

980 case CKM_RC2_CBC_PAD:

981 rc2_params = (CK_RC2_CBC_PARAMS *)param->data;

982 *len = sizeof(rc2_params->iv);

983 return &rc2_params->iv[0];

984 case CKM_RC5_CBC:

985 case CKM_RC5_CBC_PAD:

986 rc5_cbc_params = (CK_RC5_CBC_PARAMS *) param->data;

987 *len = rc5_cbc_params->ulIvLen;

988 return rc5_cbc_params->pIv;

989 case CKM_SEED_CBC:

990 case CKM_CAMELLIA_CBC:

991 case CKM_AES_CBC:

992 case CKM_DES_CBC:

993 case CKM_DES3_CBC:

994 case CKM_IDEA_CBC:

995 case CKM_CDMF_CBC:

996 case CKM_CAST_CBC:

997 case CKM_CAST3_CBC:

998 case CKM_CAST5_CBC:

999 case CKM_CAMELLIA_CBC_PAD:

1000 case CKM_AES_CBC_PAD:

1001 case CKM_DES_CBC_PAD:

1002 case CKM_DES3_CBC_PAD:

1003 case CKM_IDEA_CBC_PAD:

1004 case CKM_CDMF_CBC_PAD:

1005 case CKM_CAST_CBC_PAD:

1006 case CKM_CAST3_CBC_PAD:

1007 case CKM_CAST5_CBC_PAD:

1008 case CKM_SKIPJACK_CBC64:

1009 case CKM_SKIPJACK_ECB64:

1010 case CKM_SKIPJACK_OFB64:

1011 case CKM_SKIPJACK_CFB64:

1012 case CKM_SKIPJACK_CFB32:

1013 case CKM_SKIPJACK_CFB16:

1014 case CKM_SKIPJACK_CFB8:

1015 case CKM_BATON_ECB128:

1016 case CKM_BATON_ECB96:

1017 case CKM_BATON_CBC128:

1018 case CKM_BATON_COUNTER:

1019 case CKM_BATON_SHUFFLE:

1020 case CKM_JUNIPER_ECB128:

1021 case CKM_JUNIPER_CBC128:

1022 case CKM_JUNIPER_COUNTER:

1023 case CKM_JUNIPER_SHUFFLE:

1024 break;

1025 /* unknown mechanism, pass IV in if it's there */

1026 default:

1027 break;

1028 }

1029 if (param->data) {

1030 *len = param->len;

1031 }

1032 return param->data;

1033 }

1034

1035 typedef struct sec_rc5cbcParameterStr {

1036 SECItem version;

1037 SECItem rounds;

1038 SECItem blockSizeInBits;

1039 SECItem iv;

1040 } sec_rc5cbcParameter;

1041

1042 static const SEC_ASN1Template sec_rc5ecb_parameter_template[] = {

1043 { SEC_ASN1_SEQUENCE,

1044 0, NULL, sizeof(sec_rc5cbcParameter) },

1045 { SEC_ASN1_INTEGER,

1046 offsetof(sec_rc5cbcParameter,version) },

1047 { SEC_ASN1_INTEGER,

1048 offsetof(sec_rc5cbcParameter,rounds) },

1049 { SEC_ASN1_INTEGER,

1050 offsetof(sec_rc5cbcParameter,blockSizeInBits) },

1051 { 0 }

1052 };

1053

1054 static const SEC_ASN1Template sec_rc5cbc_parameter_template[] = {

1055 { SEC_ASN1_SEQUENCE,

1056 0, NULL, sizeof(sec_rc5cbcParameter) },

1057 { SEC_ASN1_INTEGER,

1058 offsetof(sec_rc5cbcParameter,version) },

1059 { SEC_ASN1_INTEGER,

1060 offsetof(sec_rc5cbcParameter,rounds) },

1061 { SEC_ASN1_INTEGER,

1062 offsetof(sec_rc5cbcParameter,blockSizeInBits) },

1063 { SEC_ASN1_OCTET_STRING,

1064 offsetof(sec_rc5cbcParameter,iv) },

1065 { 0 }

1066 };

1067

1068 typedef struct sec_rc2cbcParameterStr {

1069 SECItem rc2ParameterVersion;

1070 SECItem iv;

1071 } sec_rc2cbcParameter;

1072

1073 static const SEC_ASN1Template sec_rc2cbc_parameter_template[] = {

1074 { SEC_ASN1_SEQUENCE,

1075 0, NULL, sizeof(sec_rc2cbcParameter) },

1076 { SEC_ASN1_INTEGER,

1077 offsetof(sec_rc2cbcParameter,rc2ParameterVersion) },

1078 { SEC_ASN1_OCTET_STRING,

1079 offsetof(sec_rc2cbcParameter,iv) },

1080 { 0 }

1081 };

1082

1083 static const SEC_ASN1Template sec_rc2ecb_parameter_template[] = {

1084 { SEC_ASN1_SEQUENCE,

1085 0, NULL, sizeof(sec_rc2cbcParameter) },

1086 { SEC_ASN1_INTEGER,

1087 offsetof(sec_rc2cbcParameter,rc2ParameterVersion) },

1088 { 0 }

1089 };

1090

1091 /* S/MIME picked id values to represent differnt keysizes */

1092 /* I do have a formula, but it ain't pretty, and it only works because you

1093 * can always match three points to a parabola:) */

1094 static unsigned char rc2_map(SECItem *version)

1095 {

1096 long x;

1097

1098 x = DER_GetInteger(version);

1099

1100 switch (x) {

1101 case 58: return 128;

1102 case 120: return 64;

1103 case 160: return 40;

1104 }

1105 return 128;

1106 }

1107

1108 static unsigned long rc2_unmap(unsigned long x)

1109 {

1110 switch (x) {

1111 case 128: return 58;

1112 case 64: return 120;

1113 case 40: return 160;

1114 }

1115 return 58;

1116 }

1117

1118

1119

1120 /* Generate a mechaism param from a type, and iv. */

1121 SECItem *

1122 PK11_ParamFromAlgid(SECAlgorithmID *algid)

1123 {

1124 CK_RC2_CBC_PARAMS * rc2_cbc_params = NULL;

1125 CK_RC2_PARAMS * rc2_ecb_params = NULL;

1126 CK_RC5_CBC_PARAMS * rc5_cbc_params = NULL;

1127 CK_RC5_PARAMS * rc5_ecb_params = NULL;

1128 PRArenaPool * arena = NULL;

1129 SECItem * mech = NULL;

1130 SECOidTag algtag;

1131 SECStatus rv;

1132 CK_MECHANISM_TYPE type;

1133 /* initialize these to prevent UMRs in the ASN1 decoder. */

1134 SECItem iv = {siBuffer, NULL, 0};

1135 sec_rc2cbcParameter rc2 = { {siBuffer, NULL, 0}, {siBuffer, NULL, 0} };

1136 sec_rc5cbcParameter rc5 = { {siBuffer, NULL, 0}, {siBuffer, NULL, 0},

1137 {siBuffer, NULL, 0}, {siBuffer, NULL, 0} };

1138

1139 algtag = SECOID_GetAlgorithmTag(algid);

1140 type = PK11_AlgtagToMechanism(algtag);

1141

1142 mech = PORT_New(SECItem);

1143 if (mech == NULL) {

1144 return NULL;

1145 }

1146 mech->type = siBuffer;

1147 mech->data = NULL;

1148 mech->len = 0;

1149

1150 arena = PORT_NewArena(1024);

1151 if (!arena) {

1152 goto loser;

1153 }

1154

1155 /* handle the complicated cases */

1156 switch (type) {

1157 case CKM_RC2_ECB:

1158 rv = SEC_ASN1DecodeItem(arena, &rc2 ,sec_rc2ecb_parameter_template,

1159 &(algid->parameters));

1160 if (rv != SECSuccess) {

1161 goto loser;

1162 }

1163 rc2_ecb_params = PORT_New(CK_RC2_PARAMS);

1164 if (rc2_ecb_params == NULL) {

1165 goto loser;

1166 }

1167 *rc2_ecb_params = rc2_map(&rc2.rc2ParameterVersion);

1168 mech->data = (unsigned char *) rc2_ecb_params;

1169 mech->len = sizeof *rc2_ecb_params;

1170 break;

1171 case CKM_RC2_CBC:

1172 case CKM_RC2_CBC_PAD:

1173 rv = SEC_ASN1DecodeItem(arena, &rc2 ,sec_rc2cbc_parameter_template,

1174 &(algid->parameters));

1175 if (rv != SECSuccess) {

1176 goto loser;

1177 }

1178 rc2_cbc_params = PORT_New(CK_RC2_CBC_PARAMS);

1179 if (rc2_cbc_params == NULL) {

1180 goto loser;

1181 }

1182 mech->data = (unsigned char *) rc2_cbc_params;

1183 mech->len = sizeof *rc2_cbc_params;

1184 rc2_cbc_params->ulEffectiveBits = rc2_map(&rc2.rc2ParameterVersion);

1185 if (rc2.iv.len != sizeof rc2_cbc_params->iv) {

1186 PORT_SetError(SEC_ERROR_INPUT_LEN);

1187 goto loser;

1188 }

1189 PORT_Memcpy(rc2_cbc_params->iv, rc2.iv.data, rc2.iv.len);

1190 break;

1191 case CKM_RC5_ECB:

1192 rv = SEC_ASN1DecodeItem(arena, &rc5 ,sec_rc5ecb_parameter_template,

1193 &(algid->parameters));

1194 if (rv != SECSuccess) {

1195 goto loser;

1196 }

1197 rc5_ecb_params = PORT_New(CK_RC5_PARAMS);

1198 if (rc5_ecb_params == NULL) {

1199 goto loser;

1200 }

1201 rc5_ecb_params->ulRounds = DER_GetInteger(&rc5.rounds);

1202 rc5_ecb_params->ulWordsize = DER_GetInteger(&rc5.blockSizeInBits)/8;

1203 mech->data = (unsigned char *) rc5_ecb_params;

1204 mech->len = sizeof *rc5_ecb_params;

1205 break;

1206 case CKM_RC5_CBC:

1207 case CKM_RC5_CBC_PAD:

1208 rv = SEC_ASN1DecodeItem(arena, &rc5 ,sec_rc5cbc_parameter_template,

1209 &(algid->parameters));

1210 if (rv != SECSuccess) {

1211 goto loser;

1212 }

1213 rc5_cbc_params = (CK_RC5_CBC_PARAMS *)

1214 PORT_Alloc(sizeof(CK_RC5_CBC_PARAMS) + rc5.iv.len);

1215 if (rc5_cbc_params == NULL) {

1216 goto loser;

1217 }

1218 mech->data = (unsigned char *) rc5_cbc_params;

1219 mech->len = sizeof *rc5_cbc_params;

1220 rc5_cbc_params->ulRounds = DER_GetInteger(&rc5.rounds);

1221 rc5_cbc_params->ulWordsize = DER_GetInteger(&rc5.blockSizeInBits)/8;

1222 rc5_cbc_params->pIv = ((CK_BYTE_PTR)rc5_cbc_params)

1223 + sizeof(CK_RC5_CBC_PARAMS);

1224 rc5_cbc_params->ulIvLen = rc5.iv.len;

1225 PORT_Memcpy(rc5_cbc_params->pIv, rc5.iv.data, rc5.iv.len);

1226 break;

1227 case CKM_PBE_MD2_DES_CBC:

1228 case CKM_PBE_MD5_DES_CBC:

1229 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

1230 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

1231 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

1232 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

1233 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

1234 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

1235 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

1236 case CKM_PBE_SHA1_DES2_EDE_CBC:

1237 case CKM_PBE_SHA1_DES3_EDE_CBC:

1238 case CKM_PBE_SHA1_RC2_40_CBC:

1239 case CKM_PBE_SHA1_RC2_128_CBC:

1240 case CKM_PBE_SHA1_RC4_40:

1241 case CKM_PBE_SHA1_RC4_128:

1242 case CKM_PKCS5_PBKD2:

1243 rv = pbe_PK11AlgidToParam(algid,mech);

1244 if (rv != SECSuccess) {

1245 goto loser;

1246 }

1247 break;

1248 case CKM_RC4:

1249 case CKM_SEED_ECB:

1250 case CKM_CAMELLIA_ECB:

1251 case CKM_AES_ECB:

1252 case CKM_DES_ECB:

1253 case CKM_DES3_ECB:

1254 case CKM_IDEA_ECB:

1255 case CKM_CDMF_ECB:

1256 case CKM_CAST_ECB:

1257 case CKM_CAST3_ECB:

1258 case CKM_CAST5_ECB:

1259 break;

1260

1261 default:

1262 if (pk11_lookup(type)->iv == 0) {

1263 break;

1264 }

1265 /* FALL THROUGH */

1266 case CKM_SEED_CBC:

1267 case CKM_CAMELLIA_CBC:

1268 case CKM_AES_CBC:

1269 case CKM_DES_CBC:

1270 case CKM_DES3_CBC:

1271 case CKM_IDEA_CBC:

1272 case CKM_CDMF_CBC:

1273 case CKM_CAST_CBC:

1274 case CKM_CAST3_CBC:

1275 case CKM_CAST5_CBC:

1276 case CKM_SEED_CBC_PAD:

1277 case CKM_CAMELLIA_CBC_PAD:

1278 case CKM_AES_CBC_PAD:

1279 case CKM_DES_CBC_PAD:

1280 case CKM_DES3_CBC_PAD:

1281 case CKM_IDEA_CBC_PAD:

1282 case CKM_CDMF_CBC_PAD:

1283 case CKM_CAST_CBC_PAD:

1284 case CKM_CAST3_CBC_PAD:

1285 case CKM_CAST5_CBC_PAD:

1286 case CKM_SKIPJACK_CBC64:

1287 case CKM_SKIPJACK_ECB64:

1288 case CKM_SKIPJACK_OFB64:

1289 case CKM_SKIPJACK_CFB64:

1290 case CKM_SKIPJACK_CFB32:

1291 case CKM_SKIPJACK_CFB16:

1292 case CKM_SKIPJACK_CFB8:

1293 case CKM_BATON_ECB128:

1294 case CKM_BATON_ECB96:

1295 case CKM_BATON_CBC128:

1296 case CKM_BATON_COUNTER:

1297 case CKM_BATON_SHUFFLE:

1298 case CKM_JUNIPER_ECB128:

1299 case CKM_JUNIPER_CBC128:

1300 case CKM_JUNIPER_COUNTER:

1301 case CKM_JUNIPER_SHUFFLE:

1302 /* simple cases are simply octet string encoded IVs */

1303 rv = SEC_ASN1DecodeItem(arena, &iv,

1304 SEC_ASN1_GET(SEC_OctetStringTemplate),

1305 &(algid->parameters));

1306 if (rv != SECSuccess \|\| iv.data == NULL) {

1307 goto loser;

1308 }

1309 /* XXX Should be some IV length sanity check here. */

1310 mech->data = (unsigned char*)PORT_Alloc(iv.len);

1311 if (mech->data == NULL) {

1312 goto loser;

1313 }

1314 PORT_Memcpy(mech->data, iv.data, iv.len);

1315 mech->len = iv.len;

1316 break;

1317 }

1318 PORT_FreeArena(arena, PR_FALSE);

1319 return mech;

1320

1321 loser:

1322 if (arena)

1323 PORT_FreeArena(arena, PR_FALSE);

1324 SECITEM_FreeItem(mech,PR_TRUE);

1325 return NULL;

1326 }

1327

1328 /*

1329 * Generate an IV for the given mechanism

1330 */

1331 static SECStatus

1332 pk11_GenIV(CK_MECHANISM_TYPE type, SECItem *iv) {

1333 int iv_size = PK11_GetIVLength(type);

1334 SECStatus rv;

1335

1336 iv->len = iv_size;

1337 if (iv_size == 0) {

1338 iv->data = NULL;

1339 return SECSuccess;

1340 }

1341

1342 iv->data = (unsigned char *) PORT_Alloc(iv_size);

1343 if (iv->data == NULL) {

1344 iv->len = 0;

1345 return SECFailure;

1346 }

1347

1348 rv = PK11_GenerateRandom(iv->data,iv->len);

1349 if (rv != SECSuccess) {

1350 PORT_Free(iv->data);

1351 iv->data = NULL; iv->len = 0;

1352 return SECFailure;

1353 }

1354 return SECSuccess;

1355 }

1356

1357

1358 /*

1359 * create a new parameter block from the passed in MECHANISM and the

1360 * key. Use Netscape's S/MIME Rules for the New param block.

1361 */

1362 SECItem *

1363 pk11_GenerateNewParamWithKeyLen(CK_MECHANISM_TYPE type, int keyLen)

1364 {

1365 CK_RC2_CBC_PARAMS *rc2_params;

1366 CK_RC2_PARAMS *rc2_ecb_params;

1367 SECItem *mech;

1368 SECItem iv;

1369 SECStatus rv;

1370

1371

1372 mech = (SECItem *) PORT_Alloc(sizeof(SECItem));

1373 if (mech == NULL) return NULL;

1374

1375 rv = SECSuccess;

1376 mech->type = siBuffer;

1377 switch (type) {

1378 case CKM_RC4:

1379 case CKM_SEED_ECB:

1380 case CKM_CAMELLIA_ECB:

1381 case CKM_AES_ECB:

1382 case CKM_DES_ECB:

1383 case CKM_DES3_ECB:

1384 case CKM_IDEA_ECB:

1385 case CKM_CDMF_ECB:

1386 case CKM_CAST_ECB:

1387 case CKM_CAST3_ECB:

1388 case CKM_CAST5_ECB:

1389 mech->data = NULL;

1390 mech->len = 0;

1391 break;

1392 case CKM_RC2_ECB:

1393 rc2_ecb_params = (CK_RC2_PARAMS *)PORT_Alloc(sizeof(CK_RC2_PARAMS));

1394 if (rc2_ecb_params == NULL) {

1395 rv = SECFailure;

1396 break;

1397 }

1398 /* NOTE PK11_GetKeyLength can return -1 if the key isn't and RC2, RC5,

1399 * or RC4 key. Of course that wouldn't happen here doing RC2:).*/

1400 rc2_ecb_params = keyLen ? keyLen8 : 128;

1401 mech->data = (unsigned char *) rc2_ecb_params;

1402 mech->len = sizeof(CK_RC2_PARAMS);

1403 break;

1404 case CKM_RC2_CBC:

1405 case CKM_RC2_CBC_PAD:

1406 rv = pk11_GenIV(type,&iv);

1407 if (rv != SECSuccess) {

1408 break;

1409 }

1410 rc2_params = (CK_RC2_CBC_PARAMS *)PORT_Alloc(sizeof(CK_RC2_CBC_PARAMS));

1411 if (rc2_params == NULL) {

1412 PORT_Free(iv.data);

1413 rv = SECFailure;

1414 break;

1415 }

1416 /* NOTE PK11_GetKeyLength can return -1 if the key isn't and RC2, RC5,

1417 * or RC4 key. Of course that wouldn't happen here doing RC2:).*/

1418 rc2_params->ulEffectiveBits = keyLen ? keyLen*8 : 128;

1419 if (iv.data)

1420 PORT_Memcpy(rc2_params->iv,iv.data,sizeof(rc2_params->iv));

1421 mech->data = (unsigned char *) rc2_params;

1422 mech->len = sizeof(CK_RC2_CBC_PARAMS);

1423 PORT_Free(iv.data);

1424 break;

1425 case CKM_RC5_ECB:

1426 PORT_Free(mech);

1427 return PK11_ParamFromIV(type,NULL);

1428 case CKM_RC5_CBC:

1429 case CKM_RC5_CBC_PAD:

1430 rv = pk11_GenIV(type,&iv);

1431 if (rv != SECSuccess) {

1432 break;

1433 }

1434 PORT_Free(mech);

1435 return PK11_ParamFromIV(type,&iv);

1436 default:

1437 if (pk11_lookup(type)->iv == 0) {

1438 mech->data = NULL;

1439 mech->len = 0;

1440 break;

1441 }

1442 case CKM_SEED_CBC:

1443 case CKM_CAMELLIA_CBC:

1444 case CKM_AES_CBC:

1445 case CKM_DES_CBC:

1446 case CKM_DES3_CBC:

1447 case CKM_IDEA_CBC:

1448 case CKM_CDMF_CBC:

1449 case CKM_CAST_CBC:

1450 case CKM_CAST3_CBC:

1451 case CKM_CAST5_CBC:

1452 case CKM_DES_CBC_PAD:

1453 case CKM_DES3_CBC_PAD:

1454 case CKM_IDEA_CBC_PAD:

1455 case CKM_CDMF_CBC_PAD:

1456 case CKM_CAST_CBC_PAD:

1457 case CKM_CAST3_CBC_PAD:

1458 case CKM_CAST5_CBC_PAD:

1459 case CKM_SKIPJACK_CBC64:

1460 case CKM_SKIPJACK_ECB64:

1461 case CKM_SKIPJACK_OFB64:

1462 case CKM_SKIPJACK_CFB64:

1463 case CKM_SKIPJACK_CFB32:

1464 case CKM_SKIPJACK_CFB16:

1465 case CKM_SKIPJACK_CFB8:

1466 case CKM_BATON_ECB128:

1467 case CKM_BATON_ECB96:

1468 case CKM_BATON_CBC128:

1469 case CKM_BATON_COUNTER:

1470 case CKM_BATON_SHUFFLE:

1471 case CKM_JUNIPER_ECB128:

1472 case CKM_JUNIPER_CBC128:

1473 case CKM_JUNIPER_COUNTER:

1474 case CKM_JUNIPER_SHUFFLE:

1475 rv = pk11_GenIV(type,&iv);

1476 if (rv != SECSuccess) {

1477 break;

1478 }

1479 mech->data = (unsigned char*)PORT_Alloc(iv.len);

1480 if (mech->data == NULL) {

1481 PORT_Free(iv.data);

1482 rv = SECFailure;

1483 break;

1484 }

1485 PORT_Memcpy(mech->data,iv.data,iv.len);

1486 mech->len = iv.len;

1487 PORT_Free(iv.data);

1488 break;

1489 }

1490 if (rv != SECSuccess) {

1491 SECITEM_FreeItem(mech,PR_TRUE);

1492 return NULL;

1493 }

1494 return mech;

1495

1496 }

1497

1498 SECItem *

1499 PK11_GenerateNewParam(CK_MECHANISM_TYPE type, PK11SymKey *key)

1500 {

1501 int keyLen = key ? PK11_GetKeyLength(key) : 0;

1502

1503 return pk11_GenerateNewParamWithKeyLen(type, keyLen);

1504 }

1505

1506 #define RC5_V10 0x10

1507

1508 /* turn a PKCS #11 parameter into a DER Encoded Algorithm ID */

1509 SECStatus

1510 PK11_ParamToAlgid(SECOidTag algTag, SECItem *param,

1511 PRArenaPool arena, SECAlgorithmID algid) {

1512 CK_RC2_CBC_PARAMS *rc2_params;

1513 sec_rc2cbcParameter rc2;

1514 CK_RC5_CBC_PARAMS *rc5_params;

1515 sec_rc5cbcParameter rc5;

1516 CK_MECHANISM_TYPE type = PK11_AlgtagToMechanism(algTag);

1517 SECItem *newParams = NULL;

1518 SECStatus rv = SECFailure;

1519 unsigned long rc2version;

1520

1521 switch (type) {

1522 case CKM_RC4:

1523 case CKM_SEED_ECB:

1524 case CKM_CAMELLIA_ECB:

1525 case CKM_AES_ECB:

1526 case CKM_DES_ECB:

1527 case CKM_DES3_ECB:

1528 case CKM_IDEA_ECB:

1529 case CKM_CDMF_ECB:

1530 case CKM_CAST_ECB:

1531 case CKM_CAST3_ECB:

1532 case CKM_CAST5_ECB:

1533 newParams = NULL;

1534 rv = SECSuccess;

1535 break;

1536 case CKM_RC2_ECB:

1537 break;

1538 case CKM_RC2_CBC:

1539 case CKM_RC2_CBC_PAD:

1540 rc2_params = (CK_RC2_CBC_PARAMS *)param->data;

1541 rc2version = rc2_unmap(rc2_params->ulEffectiveBits);

1542 if (SEC_ASN1EncodeUnsignedInteger (NULL, &(rc2.rc2ParameterVersion),

1543 rc2version) == NULL)

1544 break;

1545 rc2.iv.data = rc2_params->iv;

1546 rc2.iv.len = sizeof(rc2_params->iv);

1547 newParams = SEC_ASN1EncodeItem (NULL, NULL, &rc2,

1548 sec_rc2cbc_parameter_template);

1549 PORT_Free(rc2.rc2ParameterVersion.data);

1550 if (newParams == NULL)

1551 break;

1552 rv = SECSuccess;

1553 break;

1554

1555 case CKM_RC5_ECB: /* well not really... */

1556 break;

1557 case CKM_RC5_CBC:

1558 case CKM_RC5_CBC_PAD:

1559 rc5_params = (CK_RC5_CBC_PARAMS *)param->data;

1560 if (SEC_ASN1EncodeUnsignedInteger (NULL, &rc5.version, RC5_V10) == NULL)

1561 break;

1562 if (SEC_ASN1EncodeUnsignedInteger (NULL, &rc5.blockSizeInBits,

1563 rc5_params->ulWordsize*8) == NULL) {

1564 PORT_Free(rc5.version.data);

1565 break;

1566 }

1567 if (SEC_ASN1EncodeUnsignedInteger (NULL, &rc5.rounds,

1568 rc5_params->ulWordsize*8) == NULL) {

1569 PORT_Free(rc5.blockSizeInBits.data);

1570 PORT_Free(rc5.version.data);

1571 break;

1572 }

1573 rc5.iv.data = rc5_params->pIv;

1574 rc5.iv.len = rc5_params->ulIvLen;

1575 newParams = SEC_ASN1EncodeItem (NULL, NULL, &rc5,

1576 sec_rc5cbc_parameter_template);

1577 PORT_Free(rc5.version.data);

1578 PORT_Free(rc5.blockSizeInBits.data);

1579 PORT_Free(rc5.rounds.data);

1580 if (newParams == NULL)

1581 break;

1582 rv = SECSuccess;

1583 break;

1584 case CKM_PBE_MD2_DES_CBC:

1585 case CKM_PBE_MD5_DES_CBC:

1586 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

1587 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

1588 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

1589 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

1590 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

1591 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

1592 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

1593 case CKM_PBE_SHA1_DES3_EDE_CBC:

1594 case CKM_PBE_SHA1_DES2_EDE_CBC:

1595 case CKM_PBE_SHA1_RC2_40_CBC:

1596 case CKM_PBE_SHA1_RC2_128_CBC:

1597 case CKM_PBE_SHA1_RC4_40:

1598 case CKM_PBE_SHA1_RC4_128:

1599 return PBE_PK11ParamToAlgid(algTag, param, arena, algid);

1600 default:

1601 if (pk11_lookup(type)->iv == 0) {

1602 rv = SECSuccess;

1603 newParams = NULL;

1604 break;

1605 }

1606 case CKM_SEED_CBC:

1607 case CKM_CAMELLIA_CBC:

1608 case CKM_AES_CBC:

1609 case CKM_DES_CBC:

1610 case CKM_DES3_CBC:

1611 case CKM_IDEA_CBC:

1612 case CKM_CDMF_CBC:

1613 case CKM_CAST_CBC:

1614 case CKM_CAST3_CBC:

1615 case CKM_CAST5_CBC:

1616 case CKM_DES_CBC_PAD:

1617 case CKM_DES3_CBC_PAD:

1618 case CKM_IDEA_CBC_PAD:

1619 case CKM_CDMF_CBC_PAD:

1620 case CKM_CAST_CBC_PAD:

1621 case CKM_CAST3_CBC_PAD:

1622 case CKM_CAST5_CBC_PAD:

1623 case CKM_SKIPJACK_CBC64:

1624 case CKM_SKIPJACK_ECB64:

1625 case CKM_SKIPJACK_OFB64:

1626 case CKM_SKIPJACK_CFB64:

1627 case CKM_SKIPJACK_CFB32:

1628 case CKM_SKIPJACK_CFB16:

1629 case CKM_SKIPJACK_CFB8:

1630 case CKM_BATON_ECB128:

1631 case CKM_BATON_ECB96:

1632 case CKM_BATON_CBC128:

1633 case CKM_BATON_COUNTER:

1634 case CKM_BATON_SHUFFLE:

1635 case CKM_JUNIPER_ECB128:

1636 case CKM_JUNIPER_CBC128:

1637 case CKM_JUNIPER_COUNTER:

1638 case CKM_JUNIPER_SHUFFLE:

1639 newParams = SEC_ASN1EncodeItem(NULL,NULL,param,

1640 SEC_ASN1_GET(SEC_OctetStringTemplate) );

1641 if (newParams == NULL)

1642 break;

1643 rv = SECSuccess;

1644 break;

1645 }

1646

1647 if (rv != SECSuccess) {

1648 if (newParams) SECITEM_FreeItem(newParams,PR_TRUE);

1649 return rv;

1650 }

1651

1652 rv = SECOID_SetAlgorithmID(arena, algid, algTag, newParams);

1653 SECITEM_FreeItem(newParams,PR_TRUE);

1654 return rv;

1655 }

1656

1657 /* turn an OID algorithm tag into a PKCS #11 mechanism. This allows us to

1658 * map OID's directly into the PKCS #11 mechanism we want to call. We find

1659 * this mapping in our standard OID table */

1660 CK_MECHANISM_TYPE

1661 PK11_AlgtagToMechanism(SECOidTag algTag) {

1662 SECOidData *oid = SECOID_FindOIDByTag(algTag);

1663

1664 if (oid) return (CK_MECHANISM_TYPE) oid->mechanism;

1665 return CKM_INVALID_MECHANISM;

1666 }

1667

1668 /* turn a mechanism into an oid. */

1669 SECOidTag

1670 PK11_MechanismToAlgtag(CK_MECHANISM_TYPE type) {

1671 SECOidData *oid = SECOID_FindOIDByMechanism((unsigned long)type);

1672

1673 if (oid) return oid->offset;

1674 return SEC_OID_UNKNOWN;

1675 }

1676

1677 /* Determine appropriate blocking mechanism, used when wrapping private keys

1678 * which require PKCS padding. If the mechanism does not map to a padding

1679 * mechanism, we simply return the mechanism.

1680 */

1681 CK_MECHANISM_TYPE

1682 PK11_GetPadMechanism(CK_MECHANISM_TYPE type) {

1683 switch(type) {

1684 case CKM_SEED_CBC:

1685 return CKM_SEED_CBC_PAD;

1686 case CKM_CAMELLIA_CBC:

1687 return CKM_CAMELLIA_CBC_PAD;

1688 case CKM_AES_CBC:

1689 return CKM_AES_CBC_PAD;

1690 case CKM_DES_CBC:

1691 return CKM_DES_CBC_PAD;

1692 case CKM_DES3_CBC:

1693 return CKM_DES3_CBC_PAD;

1694 case CKM_RC2_CBC:

1695 return CKM_RC2_CBC_PAD;

1696 case CKM_CDMF_CBC:

1697 return CKM_CDMF_CBC_PAD;

1698 case CKM_CAST_CBC:

1699 return CKM_CAST_CBC_PAD;

1700 case CKM_CAST3_CBC:

1701 return CKM_CAST3_CBC_PAD;

1702 case CKM_CAST5_CBC:

1703 return CKM_CAST5_CBC_PAD;

1704 case CKM_RC5_CBC:

1705 return CKM_RC5_CBC_PAD;

1706 case CKM_IDEA_CBC:

1707 return CKM_IDEA_CBC_PAD;

1708 default:

1709 break;

1710 }

1711

1712 return type;

1713 }

1714

1715 static PRBool

1716 pk11_isAllZero(unsigned char *data,int len) {

1717 while (len--) {

1718 if (*data++) {

1719 return PR_FALSE;

1720 }

1721 }

1722 return PR_TRUE;

1723 }

1724

1725 CK_RV

1726 PK11_MapPBEMechanismToCryptoMechanism(CK_MECHANISM_PTR pPBEMechanism,

1727 CK_MECHANISM_PTR pCryptoMechanism,

1728 SECItem *pbe_pwd, PRBool faulty3DES)

1729 {

1730 int iv_len = 0;

1731 CK_PBE_PARAMS_PTR pPBEparams;

1732 CK_RC2_CBC_PARAMS_PTR rc2_params;

1733 CK_ULONG rc2_key_len;

1734

1735 if((pPBEMechanism == CK_NULL_PTR) \|\| (pCryptoMechanism == CK_NULL_PTR)) {

1736 return CKR_HOST_MEMORY;

1737 }

1738

1739 /* pkcs5 v2 cannot be supported by this interface.

1740 * use PK11_GetPBECryptoMechanism instead.

1741 */

1742 if ((pPBEMechanism->mechanism == CKM_INVALID_MECHANISM) \|\|

1743 (pPBEMechanism->mechanism == CKM_PKCS5_PBKD2)) {

1744 return CKR_MECHANISM_INVALID;

1745 }

1746

1747 pPBEparams = (CK_PBE_PARAMS_PTR)pPBEMechanism->pParameter;

1748 iv_len = PK11_GetIVLength(pPBEMechanism->mechanism);

1749

1750 if (iv_len) {

1751 if (pk11_isAllZero(pPBEparams->pInitVector,iv_len)) {

1752 SECItem param;

1753 PK11SymKey *symKey;

1754 PK11SlotInfo *intSlot = PK11_GetInternalSlot();

1755

1756 if (intSlot == NULL) {

1757 return CKR_DEVICE_ERROR;

1758 }

1759

1760 param.data = pPBEMechanism->pParameter;

1761 param.len = pPBEMechanism->ulParameterLen;

1762

1763 symKey = PK11_RawPBEKeyGen(intSlot,

1764 pPBEMechanism->mechanism, &param, pbe_pwd, faulty3DES, NULL);

1765 PK11_FreeSlot(intSlot);

1766 if (symKey== NULL) {

1767 return CKR_DEVICE_ERROR; /* sigh */

1768 }

1769 PK11_FreeSymKey(symKey);

1770 }

1771 }

1772

1773 switch(pPBEMechanism->mechanism) {

1774 case CKM_PBE_MD2_DES_CBC:

1775 case CKM_PBE_MD5_DES_CBC:

1776 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

1777 pCryptoMechanism->mechanism = CKM_DES_CBC;

1778 goto have_crypto_mechanism;

1779 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

1780 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

1781 case CKM_PBE_SHA1_DES3_EDE_CBC:

1782 case CKM_PBE_SHA1_DES2_EDE_CBC:

1783 pCryptoMechanism->mechanism = CKM_DES3_CBC;

1784 have_crypto_mechanism:

1785 pCryptoMechanism->pParameter = PORT_Alloc(iv_len);

1786 pCryptoMechanism->ulParameterLen = (CK_ULONG)iv_len;

1787 if(pCryptoMechanism->pParameter == NULL) {

1788 return CKR_HOST_MEMORY;

1789 }

1790 PORT_Memcpy((unsigned char *)(pCryptoMechanism->pParameter),

1791 (unsigned char *)(pPBEparams->pInitVector),

1792 iv_len);

1793 break;

1794 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

1795 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

1796 case CKM_PBE_SHA1_RC4_40:

1797 case CKM_PBE_SHA1_RC4_128:

1798 pCryptoMechanism->mechanism = CKM_RC4;

1799 pCryptoMechanism->ulParameterLen = 0;

1800 pCryptoMechanism->pParameter = CK_NULL_PTR;

1801 break;

1802 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

1803 case CKM_PBE_SHA1_RC2_40_CBC:

1804 rc2_key_len = 40;

1805 goto have_key_len;

1806 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

1807 rc2_key_len = 128;

1808 have_key_len:

1809 pCryptoMechanism->mechanism = CKM_RC2_CBC;

1810 pCryptoMechanism->ulParameterLen = (CK_ULONG)

1811 sizeof(CK_RC2_CBC_PARAMS);

1812 pCryptoMechanism->pParameter = (CK_RC2_CBC_PARAMS_PTR)

1813 PORT_ZAlloc(sizeof(CK_RC2_CBC_PARAMS));

1814 if(pCryptoMechanism->pParameter == NULL) {

1815 return CKR_HOST_MEMORY;

1816 }

1817 rc2_params = (CK_RC2_CBC_PARAMS_PTR)pCryptoMechanism->pParameter;

1818 PORT_Memcpy((unsigned char *)rc2_params->iv,

1819 (unsigned char *)pPBEparams->pInitVector,

1820 iv_len);

1821 rc2_params->ulEffectiveBits = rc2_key_len;

1822 break;

1823 default:

1824 return CKR_MECHANISM_INVALID;

1825 }

1826

1827 return CKR_OK;

1828 }

1829

1830 /* Make a Key type to an appropriate signing/verification mechanism */

1831 CK_MECHANISM_TYPE

1832 PK11_MapSignKeyType(KeyType keyType)

1833 {

1834 switch (keyType) {

1835 case rsaKey:

1836 return CKM_RSA_PKCS;

1837 case fortezzaKey:

1838 case dsaKey:

1839 return CKM_DSA;

1840 case ecKey:

1841 return CKM_ECDSA;

1842 case dhKey:

1843 default:

1844 break;

1845 }

1846 return CKM_INVALID_MECHANISM;

1847 }

1848

1849 CK_MECHANISM_TYPE

1850 pk11_mapWrapKeyType(KeyType keyType)

1851 {

1852 switch (keyType) {

1853 case rsaKey:

1854 return CKM_RSA_PKCS;

1855 /* Add fortezza?? */

1856 default:

1857 break;

1858 }

1859 return CKM_INVALID_MECHANISM;

1860 }

1861

1862 SECOidTag

1863 PK11_FortezzaMapSig(SECOidTag algTag)

1864 {

1865 switch (algTag) {

1866 case SEC_OID_MISSI_KEA_DSS:

1867 case SEC_OID_MISSI_DSS:

1868 case SEC_OID_MISSI_DSS_OLD:

1869 case SEC_OID_MISSI_KEA_DSS_OLD:

1870 case SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST:

1871 return SEC_OID_ANSIX9_DSA_SIGNATURE;

1872 default:

1873 break;

1874 }

1875 return algTag;

1876 }

OLD	NEW

« no previous file with comments | « mozilla/security/nss/lib/pk11wrap/pk11load.c ('k') | mozilla/security/nss/lib/pk11wrap/pk11merge.c » ('j') | no next file with comments »