nss/lib/pk11wrap/pk11mech.c - Issue 2078763002: Delete bundled copy of NSS and replace with README.

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

Issue 2078763002: Delete bundled copy of NSS and replace with README. (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/nss@master

Patch Set: Delete bundled copy of NSS and replace with README. Created 4 years, 6 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

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

146 */

147 CK_MECHANISM_TYPE

148 PK11_GetKeyMechanism(CK_KEY_TYPE type)

149 {

150 switch (type) {

151 case CKK_SEED:

152 return CKM_SEED_CBC;

153 case CKK_CAMELLIA:

154 return CKM_CAMELLIA_CBC;

155 case CKK_NSS_CHACHA20:

156 return CKM_NSS_CHACHA20_POLY1305;

157 case CKK_AES:

158 return CKM_AES_CBC;

159 case CKK_DES:

160 return CKM_DES_CBC;

161 case CKK_DES3:

162 return CKM_DES3_KEY_GEN;

163 case CKK_DES2:

164 return CKM_DES2_KEY_GEN;

165 case CKK_CDMF:

166 return CKM_CDMF_CBC;

167 case CKK_RC2:

168 return CKM_RC2_CBC;

169 case CKK_RC4:

170 return CKM_RC4;

171 case CKK_RC5:

172 return CKM_RC5_CBC;

173 case CKK_SKIPJACK:

174 return CKM_SKIPJACK_CBC64;

175 case CKK_BATON:

176 return CKM_BATON_CBC128;

177 case CKK_JUNIPER:

178 return CKM_JUNIPER_CBC128;

179 case CKK_IDEA:

180 return CKM_IDEA_CBC;

181 case CKK_CAST:

182 return CKM_CAST_CBC;

183 case CKK_CAST3:

184 return CKM_CAST3_CBC;

185 case CKK_CAST5:

186 return CKM_CAST5_CBC;

187 case CKK_RSA:

188 return CKM_RSA_PKCS;

189 case CKK_DSA:

190 return CKM_DSA;

191 case CKK_DH:

192 return CKM_DH_PKCS_DERIVE;

193 case CKK_KEA:

194 return CKM_KEA_KEY_DERIVE;

195 case CKK_EC: /* CKK_ECDSA is deprecated */

196 return CKM_ECDSA;

197 case CKK_GENERIC_SECRET:

198 default:

199 return CKM_SHA_1_HMAC;

200 }

201 }

202

203 /*

204 * Get the key type needed for the given mechanism

205 */

206 CK_KEY_TYPE

207 PK11_GetKeyType(CK_MECHANISM_TYPE type,unsigned long len)

208 {

209 switch (type) {

210 case CKM_SEED_ECB:

211 case CKM_SEED_CBC:

212 case CKM_SEED_MAC:

213 case CKM_SEED_MAC_GENERAL:

214 case CKM_SEED_CBC_PAD:

215 case CKM_SEED_KEY_GEN:

216 return CKK_SEED;

217 case CKM_CAMELLIA_ECB:

218 case CKM_CAMELLIA_CBC:

219 case CKM_CAMELLIA_MAC:

220 case CKM_CAMELLIA_MAC_GENERAL:

221 case CKM_CAMELLIA_CBC_PAD:

222 case CKM_CAMELLIA_KEY_GEN:

223 return CKK_CAMELLIA;

224 case CKM_NSS_CHACHA20_POLY1305:

225 case CKM_NSS_CHACHA20_KEY_GEN:

226 return CKK_NSS_CHACHA20;

227 case CKM_AES_ECB:

228 case CKM_AES_CBC:

229 case CKM_AES_CCM:

230 case CKM_AES_CTR:

231 case CKM_AES_CTS:

232 case CKM_AES_GCM:

233 case CKM_AES_MAC:

234 case CKM_AES_MAC_GENERAL:

235 case CKM_AES_CBC_PAD:

236 case CKM_AES_KEY_GEN:

237 case CKM_NETSCAPE_AES_KEY_WRAP:

238 case CKM_NETSCAPE_AES_KEY_WRAP_PAD:

239 return CKK_AES;

240 case CKM_DES_ECB:

241 case CKM_DES_CBC:

242 case CKM_DES_MAC:

243 case CKM_DES_MAC_GENERAL:

244 case CKM_DES_CBC_PAD:

245 case CKM_DES_KEY_GEN:

246 case CKM_KEY_WRAP_LYNKS:

247 case CKM_PBE_MD2_DES_CBC:

248 case CKM_PBE_MD5_DES_CBC:

249 return CKK_DES;

250 case CKM_DES3_ECB:

251 case CKM_DES3_CBC:

252 case CKM_DES3_MAC:

253 case CKM_DES3_MAC_GENERAL:

254 case CKM_DES3_CBC_PAD:

255 return (len == 16) ? CKK_DES2 : CKK_DES3;

256 case CKM_DES2_KEY_GEN:

257 case CKM_PBE_SHA1_DES2_EDE_CBC:

258 return CKK_DES2;

259 case CKM_PBE_SHA1_DES3_EDE_CBC:

260 case CKM_DES3_KEY_GEN:

261 return CKK_DES3;

262 case CKM_CDMF_ECB:

263 case CKM_CDMF_CBC:

264 case CKM_CDMF_MAC:

265 case CKM_CDMF_MAC_GENERAL:

266 case CKM_CDMF_CBC_PAD:

267 case CKM_CDMF_KEY_GEN:

268 return CKK_CDMF;

269 case CKM_RC2_ECB:

270 case CKM_RC2_CBC:

271 case CKM_RC2_MAC:

272 case CKM_RC2_MAC_GENERAL:

273 case CKM_RC2_CBC_PAD:

274 case CKM_RC2_KEY_GEN:

275 case CKM_PBE_SHA1_RC2_128_CBC:

276 case CKM_PBE_SHA1_RC2_40_CBC:

277 return CKK_RC2;

278 case CKM_RC4:

279 case CKM_RC4_KEY_GEN:

280 return CKK_RC4;

281 case CKM_RC5_ECB:

282 case CKM_RC5_CBC:

283 case CKM_RC5_MAC:

284 case CKM_RC5_MAC_GENERAL:

285 case CKM_RC5_CBC_PAD:

286 case CKM_RC5_KEY_GEN:

287 return CKK_RC5;

288 case CKM_SKIPJACK_CBC64:

289 case CKM_SKIPJACK_ECB64:

290 case CKM_SKIPJACK_OFB64:

291 case CKM_SKIPJACK_CFB64:

292 case CKM_SKIPJACK_CFB32:

293 case CKM_SKIPJACK_CFB16:

294 case CKM_SKIPJACK_CFB8:

295 case CKM_SKIPJACK_KEY_GEN:

296 case CKM_SKIPJACK_WRAP:

297 case CKM_SKIPJACK_PRIVATE_WRAP:

298 return CKK_SKIPJACK;

299 case CKM_BATON_ECB128:

300 case CKM_BATON_ECB96:

301 case CKM_BATON_CBC128:

302 case CKM_BATON_COUNTER:

303 case CKM_BATON_SHUFFLE:

304 case CKM_BATON_WRAP:

305 case CKM_BATON_KEY_GEN:

306 return CKK_BATON;

307 case CKM_JUNIPER_ECB128:

308 case CKM_JUNIPER_CBC128:

309 case CKM_JUNIPER_COUNTER:

310 case CKM_JUNIPER_SHUFFLE:

311 case CKM_JUNIPER_WRAP:

312 case CKM_JUNIPER_KEY_GEN:

313 return CKK_JUNIPER;

314 case CKM_IDEA_CBC:

315 case CKM_IDEA_ECB:

316 case CKM_IDEA_MAC:

317 case CKM_IDEA_MAC_GENERAL:

318 case CKM_IDEA_CBC_PAD:

319 case CKM_IDEA_KEY_GEN:

320 return CKK_IDEA;

321 case CKM_CAST_ECB:

322 case CKM_CAST_CBC:

323 case CKM_CAST_MAC:

324 case CKM_CAST_MAC_GENERAL:

325 case CKM_CAST_CBC_PAD:

326 case CKM_CAST_KEY_GEN:

327 case CKM_PBE_MD5_CAST_CBC:

328 return CKK_CAST;

329 case CKM_CAST3_ECB:

330 case CKM_CAST3_CBC:

331 case CKM_CAST3_MAC:

332 case CKM_CAST3_MAC_GENERAL:

333 case CKM_CAST3_CBC_PAD:

334 case CKM_CAST3_KEY_GEN:

335 case CKM_PBE_MD5_CAST3_CBC:

336 return CKK_CAST3;

337 case CKM_CAST5_ECB:

338 case CKM_CAST5_CBC:

339 case CKM_CAST5_MAC:

340 case CKM_CAST5_MAC_GENERAL:

341 case CKM_CAST5_CBC_PAD:

342 case CKM_CAST5_KEY_GEN:

343 case CKM_PBE_MD5_CAST5_CBC:

344 return CKK_CAST5;

345 case CKM_RSA_PKCS:

346 case CKM_RSA_9796:

347 case CKM_RSA_X_509:

348 case CKM_MD2_RSA_PKCS:

349 case CKM_MD5_RSA_PKCS:

350 case CKM_SHA1_RSA_PKCS:

351 case CKM_SHA224_RSA_PKCS:

352 case CKM_SHA256_RSA_PKCS:

353 case CKM_SHA384_RSA_PKCS:

354 case CKM_SHA512_RSA_PKCS:

355 case CKM_KEY_WRAP_SET_OAEP:

356 case CKM_RSA_PKCS_KEY_PAIR_GEN:

357 case CKM_RSA_X9_31_KEY_PAIR_GEN:

358 return CKK_RSA;

359 case CKM_DSA:

360 case CKM_DSA_SHA1:

361 case CKM_DSA_KEY_PAIR_GEN:

362 return CKK_DSA;

363 case CKM_DH_PKCS_DERIVE:

364 case CKM_DH_PKCS_KEY_PAIR_GEN:

365 return CKK_DH;

366 case CKM_KEA_KEY_DERIVE:

367 case CKM_KEA_KEY_PAIR_GEN:

368 return CKK_KEA;

369 case CKM_ECDSA:

370 case CKM_ECDSA_SHA1:

371 case CKM_EC_KEY_PAIR_GEN: /* aka CKM_ECDSA_KEY_PAIR_GEN */

372 case CKM_ECDH1_DERIVE:

373 return CKK_EC; /* CKK_ECDSA is deprecated */

374 case CKM_SSL3_PRE_MASTER_KEY_GEN:

375 case CKM_GENERIC_SECRET_KEY_GEN:

376 case CKM_SSL3_MASTER_KEY_DERIVE:

377 case CKM_SSL3_MASTER_KEY_DERIVE_DH:

378 case CKM_SSL3_KEY_AND_MAC_DERIVE:

379 case CKM_SSL3_SHA1_MAC:

380 case CKM_SSL3_MD5_MAC:

381 case CKM_TLS_MASTER_KEY_DERIVE:

382 case CKM_NSS_TLS_MASTER_KEY_DERIVE_SHA256:

383 case CKM_TLS_MASTER_KEY_DERIVE_DH:

384 case CKM_NSS_TLS_MASTER_KEY_DERIVE_DH_SHA256:

385 case CKM_TLS_KEY_AND_MAC_DERIVE:

386 case CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256:

387 case CKM_NSS_TLS_EXTENDED_MASTER_KEY_DERIVE:

388 case CKM_NSS_TLS_EXTENDED_MASTER_KEY_DERIVE_DH:

389 case CKM_SHA_1_HMAC:

390 case CKM_SHA_1_HMAC_GENERAL:

391 case CKM_SHA224_HMAC:

392 case CKM_SHA224_HMAC_GENERAL:

393 case CKM_SHA256_HMAC:

394 case CKM_SHA256_HMAC_GENERAL:

395 case CKM_SHA384_HMAC:

396 case CKM_SHA384_HMAC_GENERAL:

397 case CKM_SHA512_HMAC:

398 case CKM_SHA512_HMAC_GENERAL:

399 case CKM_MD2_HMAC:

400 case CKM_MD2_HMAC_GENERAL:

401 case CKM_MD5_HMAC:

402 case CKM_MD5_HMAC_GENERAL:

403 case CKM_TLS_PRF_GENERAL:

404 case CKM_NSS_TLS_PRF_GENERAL_SHA256:

405 return CKK_GENERIC_SECRET;

406 default:

407 return pk11_lookup(type)->keyType;

408 }

409 }

410

411 /*

412 * Get the Key Gen Mechanism needed for the given

413 * crypto mechanism

414 */

415 CK_MECHANISM_TYPE

416 PK11_GetKeyGen(CK_MECHANISM_TYPE type)

417 {

418 return PK11_GetKeyGenWithSize(type, 0);

419 }

420

421 CK_MECHANISM_TYPE

422 PK11_GetKeyGenWithSize(CK_MECHANISM_TYPE type, int size)

423 {

424 switch (type) {

425 case CKM_SEED_ECB:

426 case CKM_SEED_CBC:

427 case CKM_SEED_MAC:

428 case CKM_SEED_MAC_GENERAL:

429 case CKM_SEED_CBC_PAD:

430 case CKM_SEED_KEY_GEN:

431 return CKM_SEED_KEY_GEN;

432 case CKM_CAMELLIA_ECB:

433 case CKM_CAMELLIA_CBC:

434 case CKM_CAMELLIA_MAC:

435 case CKM_CAMELLIA_MAC_GENERAL:

436 case CKM_CAMELLIA_CBC_PAD:

437 case CKM_CAMELLIA_KEY_GEN:

438 return CKM_CAMELLIA_KEY_GEN;

439 case CKM_NSS_CHACHA20_POLY1305:

440 return CKM_NSS_CHACHA20_KEY_GEN;

441 case CKM_AES_ECB:

442 case CKM_AES_CBC:

443 case CKM_AES_CCM:

444 case CKM_AES_CTR:

445 case CKM_AES_CTS:

446 case CKM_AES_GCM:

447 case CKM_AES_MAC:

448 case CKM_AES_MAC_GENERAL:

449 case CKM_AES_CBC_PAD:

450 case CKM_AES_KEY_GEN:

451 return CKM_AES_KEY_GEN;

452 case CKM_DES_ECB:

453 case CKM_DES_CBC:

454 case CKM_DES_MAC:

455 case CKM_DES_MAC_GENERAL:

456 case CKM_KEY_WRAP_LYNKS:

457 case CKM_DES_CBC_PAD:

458 case CKM_DES_KEY_GEN:

459 return CKM_DES_KEY_GEN;

460 case CKM_DES3_ECB:

461 case CKM_DES3_CBC:

462 case CKM_DES3_MAC:

463 case CKM_DES3_MAC_GENERAL:

464 case CKM_DES3_CBC_PAD:

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

466 case CKM_DES3_KEY_GEN:

467 return CKM_DES3_KEY_GEN;

468 case CKM_DES2_KEY_GEN:

469 return CKM_DES2_KEY_GEN;

470 case CKM_CDMF_ECB:

471 case CKM_CDMF_CBC:

472 case CKM_CDMF_MAC:

473 case CKM_CDMF_MAC_GENERAL:

474 case CKM_CDMF_CBC_PAD:

475 case CKM_CDMF_KEY_GEN:

476 return CKM_CDMF_KEY_GEN;

477 case CKM_RC2_ECB:

478 case CKM_RC2_CBC:

479 case CKM_RC2_MAC:

480 case CKM_RC2_MAC_GENERAL:

481 case CKM_RC2_CBC_PAD:

482 case CKM_RC2_KEY_GEN:

483 return CKM_RC2_KEY_GEN;

484 case CKM_RC4:

485 case CKM_RC4_KEY_GEN:

486 return CKM_RC4_KEY_GEN;

487 case CKM_RC5_ECB:

488 case CKM_RC5_CBC:

489 case CKM_RC5_MAC:

490 case CKM_RC5_MAC_GENERAL:

491 case CKM_RC5_CBC_PAD:

492 case CKM_RC5_KEY_GEN:

493 return CKM_RC5_KEY_GEN;

494 case CKM_SKIPJACK_CBC64:

495 case CKM_SKIPJACK_ECB64:

496 case CKM_SKIPJACK_OFB64:

497 case CKM_SKIPJACK_CFB64:

498 case CKM_SKIPJACK_CFB32:

499 case CKM_SKIPJACK_CFB16:

500 case CKM_SKIPJACK_CFB8:

501 case CKM_SKIPJACK_WRAP:

502 case CKM_SKIPJACK_KEY_GEN:

503 return CKM_SKIPJACK_KEY_GEN;

504 case CKM_BATON_ECB128:

505 case CKM_BATON_ECB96:

506 case CKM_BATON_CBC128:

507 case CKM_BATON_COUNTER:

508 case CKM_BATON_SHUFFLE:

509 case CKM_BATON_WRAP:

510 case CKM_BATON_KEY_GEN:

511 return CKM_BATON_KEY_GEN;

512 case CKM_JUNIPER_ECB128:

513 case CKM_JUNIPER_CBC128:

514 case CKM_JUNIPER_COUNTER:

515 case CKM_JUNIPER_SHUFFLE:

516 case CKM_JUNIPER_WRAP:

517 case CKM_JUNIPER_KEY_GEN:

518 return CKM_JUNIPER_KEY_GEN;

519 case CKM_IDEA_CBC:

520 case CKM_IDEA_ECB:

521 case CKM_IDEA_MAC:

522 case CKM_IDEA_MAC_GENERAL:

523 case CKM_IDEA_CBC_PAD:

524 case CKM_IDEA_KEY_GEN:

525 return CKM_IDEA_KEY_GEN;

526 case CKM_CAST_ECB:

527 case CKM_CAST_CBC:

528 case CKM_CAST_MAC:

529 case CKM_CAST_MAC_GENERAL:

530 case CKM_CAST_CBC_PAD:

531 case CKM_CAST_KEY_GEN:

532 return CKM_CAST_KEY_GEN;

533 case CKM_CAST3_ECB:

534 case CKM_CAST3_CBC:

535 case CKM_CAST3_MAC:

536 case CKM_CAST3_MAC_GENERAL:

537 case CKM_CAST3_CBC_PAD:

538 case CKM_CAST3_KEY_GEN:

539 return CKM_CAST3_KEY_GEN;

540 case CKM_CAST5_ECB:

541 case CKM_CAST5_CBC:

542 case CKM_CAST5_MAC:

543 case CKM_CAST5_MAC_GENERAL:

544 case CKM_CAST5_CBC_PAD:

545 case CKM_CAST5_KEY_GEN:

546 return CKM_CAST5_KEY_GEN;

547 case CKM_RSA_PKCS:

548 case CKM_RSA_9796:

549 case CKM_RSA_X_509:

550 case CKM_MD2_RSA_PKCS:

551 case CKM_MD5_RSA_PKCS:

552 case CKM_SHA1_RSA_PKCS:

553 case CKM_SHA224_RSA_PKCS:

554 case CKM_SHA256_RSA_PKCS:

555 case CKM_SHA384_RSA_PKCS:

556 case CKM_SHA512_RSA_PKCS:

557 case CKM_KEY_WRAP_SET_OAEP:

558 case CKM_RSA_PKCS_KEY_PAIR_GEN:

559 return CKM_RSA_PKCS_KEY_PAIR_GEN;

560 case CKM_RSA_X9_31_KEY_PAIR_GEN:

561 return CKM_RSA_X9_31_KEY_PAIR_GEN;

562 case CKM_DSA:

563 case CKM_DSA_SHA1:

564 case CKM_DSA_KEY_PAIR_GEN:

565 return CKM_DSA_KEY_PAIR_GEN;

566 case CKM_DH_PKCS_DERIVE:

567 case CKM_DH_PKCS_KEY_PAIR_GEN:

568 return CKM_DH_PKCS_KEY_PAIR_GEN;

569 case CKM_KEA_KEY_DERIVE:

570 case CKM_KEA_KEY_PAIR_GEN:

571 return CKM_KEA_KEY_PAIR_GEN;

572 case CKM_ECDSA:

573 case CKM_ECDSA_SHA1:

574 case CKM_EC_KEY_PAIR_GEN: /* aka CKM_ECDSA_KEY_PAIR_GEN */

575 case CKM_ECDH1_DERIVE:

576 return CKM_EC_KEY_PAIR_GEN;

577 case CKM_SSL3_PRE_MASTER_KEY_GEN:

578 case CKM_SSL3_MASTER_KEY_DERIVE:

579 case CKM_SSL3_KEY_AND_MAC_DERIVE:

580 case CKM_SSL3_SHA1_MAC:

581 case CKM_SSL3_MD5_MAC:

582 case CKM_TLS_MASTER_KEY_DERIVE:

583 case CKM_TLS_KEY_AND_MAC_DERIVE:

584 case CKM_NSS_TLS_KEY_AND_MAC_DERIVE_SHA256:

585 case CKM_NSS_TLS_EXTENDED_MASTER_KEY_DERIVE:

586 case CKM_NSS_TLS_EXTENDED_MASTER_KEY_DERIVE_DH:

587 return CKM_SSL3_PRE_MASTER_KEY_GEN;

588 case CKM_SHA_1_HMAC:

589 case CKM_SHA_1_HMAC_GENERAL:

590 case CKM_SHA224_HMAC:

591 case CKM_SHA224_HMAC_GENERAL:

592 case CKM_SHA256_HMAC:

593 case CKM_SHA256_HMAC_GENERAL:

594 case CKM_SHA384_HMAC:

595 case CKM_SHA384_HMAC_GENERAL:

596 case CKM_SHA512_HMAC:

597 case CKM_SHA512_HMAC_GENERAL:

598 case CKM_MD2_HMAC:

599 case CKM_MD2_HMAC_GENERAL:

600 case CKM_MD5_HMAC:

601 case CKM_MD5_HMAC_GENERAL:

602 case CKM_TLS_PRF_GENERAL:

603 case CKM_NSS_TLS_PRF_GENERAL_SHA256:

604 case CKM_GENERIC_SECRET_KEY_GEN:

605 return CKM_GENERIC_SECRET_KEY_GEN;

606 case CKM_PBE_MD2_DES_CBC:

607 case CKM_PBE_MD5_DES_CBC:

608 case CKM_PBA_SHA1_WITH_SHA1_HMAC:

609 case CKM_NETSCAPE_PBE_SHA1_HMAC_KEY_GEN:

610 case CKM_NETSCAPE_PBE_MD5_HMAC_KEY_GEN:

611 case CKM_NETSCAPE_PBE_MD2_HMAC_KEY_GEN:

612 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

613 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

614 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

615 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

616 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

617 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

618 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

619 case CKM_PBE_SHA1_RC2_40_CBC:

620 case CKM_PBE_SHA1_RC2_128_CBC:

621 case CKM_PBE_SHA1_RC4_40:

622 case CKM_PBE_SHA1_RC4_128:

623 case CKM_PBE_SHA1_DES3_EDE_CBC:

624 case CKM_PBE_SHA1_DES2_EDE_CBC:

625 case CKM_PKCS5_PBKD2:

626 return type;

627 default:

628 return pk11_lookup(type)->keyGen;

629 }

630 }

631

632 /*

633 * get the mechanism block size

634 */

635 int

636 PK11_GetBlockSize(CK_MECHANISM_TYPE type,SECItem *params)

637 {

638 CK_RC5_PARAMS *rc5_params;

639 CK_RC5_CBC_PARAMS *rc5_cbc_params;

640 switch (type) {

641 case CKM_RC5_ECB:

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

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

644 return (rc5_params->ulWordsize)*2;

645 }

646 return 8;

647 case CKM_RC5_CBC:

648 case CKM_RC5_CBC_PAD:

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

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

651 return (rc5_cbc_params->ulWordsize)*2;

652 }

653 return 8;

654 case CKM_DES_ECB:

655 case CKM_DES3_ECB:

656 case CKM_RC2_ECB:

657 case CKM_IDEA_ECB:

658 case CKM_CAST_ECB:

659 case CKM_CAST3_ECB:

660 case CKM_CAST5_ECB:

661 case CKM_RC2_CBC:

662 case CKM_SKIPJACK_CBC64:

663 case CKM_SKIPJACK_ECB64:

664 case CKM_SKIPJACK_OFB64:

665 case CKM_SKIPJACK_CFB64:

666 case CKM_DES_CBC:

667 case CKM_DES3_CBC:

668 case CKM_IDEA_CBC:

669 case CKM_CAST_CBC:

670 case CKM_CAST3_CBC:

671 case CKM_CAST5_CBC:

672 case CKM_DES_CBC_PAD:

673 case CKM_DES3_CBC_PAD:

674 case CKM_RC2_CBC_PAD:

675 case CKM_IDEA_CBC_PAD:

676 case CKM_CAST_CBC_PAD:

677 case CKM_CAST3_CBC_PAD:

678 case CKM_CAST5_CBC_PAD:

679 case CKM_PBE_MD2_DES_CBC:

680 case CKM_PBE_MD5_DES_CBC:

681 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

682 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

683 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

684 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

685 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

686 case CKM_PBE_SHA1_RC2_40_CBC:

687 case CKM_PBE_SHA1_RC2_128_CBC:

688 case CKM_PBE_SHA1_DES3_EDE_CBC:

689 case CKM_PBE_SHA1_DES2_EDE_CBC:

690 return 8;

691 case CKM_SKIPJACK_CFB32:

692 case CKM_SKIPJACK_CFB16:

693 case CKM_SKIPJACK_CFB8:

694 return 4;

695 case CKM_SEED_ECB:

696 case CKM_SEED_CBC:

697 case CKM_SEED_CBC_PAD:

698 case CKM_CAMELLIA_ECB:

699 case CKM_CAMELLIA_CBC:

700 case CKM_CAMELLIA_CBC_PAD:

701 case CKM_AES_ECB:

702 case CKM_AES_CBC:

703 case CKM_AES_CBC_PAD:

704 case CKM_BATON_ECB128:

705 case CKM_BATON_CBC128:

706 case CKM_BATON_COUNTER:

707 case CKM_BATON_SHUFFLE:

708 case CKM_JUNIPER_ECB128:

709 case CKM_JUNIPER_CBC128:

710 case CKM_JUNIPER_COUNTER:

711 case CKM_JUNIPER_SHUFFLE:

712 return 16;

713 case CKM_BATON_ECB96:

714 return 12;

715 case CKM_RC4:

716 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

717 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

718 case CKM_PBE_SHA1_RC4_40:

719 case CKM_PBE_SHA1_RC4_128:

720 return 0;

721 case CKM_RSA_PKCS:

722 case CKM_RSA_9796:

723 case CKM_RSA_X_509:

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

725 return -1; /* failure */

726 default:

727 return pk11_lookup(type)->blockSize;

728 }

729 }

730

731 /*

732 * get the iv length

733 */

734 int

735 PK11_GetIVLength(CK_MECHANISM_TYPE type)

736 {

737 switch (type) {

738 case CKM_SEED_ECB:

739 case CKM_CAMELLIA_ECB:

740 case CKM_AES_ECB:

741 case CKM_DES_ECB:

742 case CKM_DES3_ECB:

743 case CKM_RC2_ECB:

744 case CKM_IDEA_ECB:

745 case CKM_SKIPJACK_WRAP:

746 case CKM_BATON_WRAP:

747 case CKM_RC5_ECB:

748 case CKM_CAST_ECB:

749 case CKM_CAST3_ECB:

750 case CKM_CAST5_ECB:

751 return 0;

752 case CKM_RC2_CBC:

753 case CKM_DES_CBC:

754 case CKM_DES3_CBC:

755 case CKM_IDEA_CBC:

756 case CKM_PBE_MD2_DES_CBC:

757 case CKM_PBE_MD5_DES_CBC:

758 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

759 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

760 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

761 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

762 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

763 case CKM_PBE_SHA1_RC2_40_CBC:

764 case CKM_PBE_SHA1_RC2_128_CBC:

765 case CKM_PBE_SHA1_DES3_EDE_CBC:

766 case CKM_PBE_SHA1_DES2_EDE_CBC:

767 case CKM_RC5_CBC:

768 case CKM_CAST_CBC:

769 case CKM_CAST3_CBC:

770 case CKM_CAST5_CBC:

771 case CKM_RC2_CBC_PAD:

772 case CKM_DES_CBC_PAD:

773 case CKM_DES3_CBC_PAD:

774 case CKM_IDEA_CBC_PAD:

775 case CKM_RC5_CBC_PAD:

776 case CKM_CAST_CBC_PAD:

777 case CKM_CAST3_CBC_PAD:

778 case CKM_CAST5_CBC_PAD:

779 return 8;

780 case CKM_SEED_CBC:

781 case CKM_SEED_CBC_PAD:

782 case CKM_CAMELLIA_CBC:

783 case CKM_CAMELLIA_CBC_PAD:

784 case CKM_AES_CBC:

785 case CKM_AES_CBC_PAD:

786 return 16;

787 case CKM_SKIPJACK_CBC64:

788 case CKM_SKIPJACK_ECB64:

789 case CKM_SKIPJACK_OFB64:

790 case CKM_SKIPJACK_CFB64:

791 case CKM_SKIPJACK_CFB32:

792 case CKM_SKIPJACK_CFB16:

793 case CKM_SKIPJACK_CFB8:

794 case CKM_BATON_ECB128:

795 case CKM_BATON_ECB96:

796 case CKM_BATON_CBC128:

797 case CKM_BATON_COUNTER:

798 case CKM_BATON_SHUFFLE:

799 case CKM_JUNIPER_ECB128:

800 case CKM_JUNIPER_CBC128:

801 case CKM_JUNIPER_COUNTER:

802 case CKM_JUNIPER_SHUFFLE:

803 return 24;

804 case CKM_RC4:

805 case CKM_RSA_PKCS:

806 case CKM_RSA_9796:

807 case CKM_RSA_X_509:

808 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

809 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

810 case CKM_PBE_SHA1_RC4_40:

811 case CKM_PBE_SHA1_RC4_128:

812 return 0;

813 default:

814 return pk11_lookup(type)->iv;

815 }

816 }

817

818

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

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

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

822 */

823 SECItem *

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

825 {

826 CK_RC2_CBC_PARAMS *rc2_params = NULL;

827 CK_RC2_PARAMS *rc2_ecb_params = NULL;

828 CK_RC5_PARAMS *rc5_params = NULL;

829 CK_RC5_CBC_PARAMS *rc5_cbc_params = NULL;

830 SECItem *param;

831

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

833 if (param == NULL) return NULL;

834 param->data = NULL;

835 param->len = 0;

836 param->type = 0;

837 switch (type) {

838 case CKM_SEED_ECB:

839 case CKM_CAMELLIA_ECB:

840 case CKM_AES_ECB:

841 case CKM_DES_ECB:

842 case CKM_DES3_ECB:

843 case CKM_RSA_PKCS:

844 case CKM_RSA_X_509:

845 case CKM_RSA_9796:

846 case CKM_IDEA_ECB:

847 case CKM_CDMF_ECB:

848 case CKM_CAST_ECB:

849 case CKM_CAST3_ECB:

850 case CKM_CAST5_ECB:

851 case CKM_RC4:

852 break;

853 case CKM_RC2_ECB:

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

855 if (rc2_ecb_params == NULL) break;

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

857 rc2_ecb_params = keyLen ? keyLen8 : 128;

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

859 param->len = sizeof(CK_RC2_PARAMS);

860 break;

861 case CKM_RC2_CBC:

862 case CKM_RC2_CBC_PAD:

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

864 if (rc2_params == NULL) break;

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

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

867 if (iv && iv->data)

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

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

870 param->len = sizeof(CK_RC2_CBC_PARAMS);

871 break;

872 case CKM_RC5_CBC:

873 case CKM_RC5_CBC_PAD:

874 rc5_cbc_params = (CK_RC5_CBC_PARAMS *)

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

876 if (rc5_cbc_params == NULL) break;

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

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

879 + sizeof(CK_RC5_CBC_PARAMS);

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

881 rc5_cbc_params->ulIvLen = iv->len;

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

883 } else {

884 rc5_cbc_params->ulWordsize = 4;

885 rc5_cbc_params->pIv = NULL;

886 rc5_cbc_params->ulIvLen = 0;

887 }

888 rc5_cbc_params->ulRounds = 16;

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

890 param->len = sizeof(CK_RC5_CBC_PARAMS);

891 break;

892 case CKM_RC5_ECB:

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

894 if (rc5_params == NULL) break;

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

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

897 } else {

898 rc5_params->ulWordsize = 4;

899 }

900 rc5_params->ulRounds = 16;

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

902 param->len = sizeof(CK_RC5_PARAMS);

903 break;

904

905 case CKM_SEED_CBC:

906 case CKM_CAMELLIA_CBC:

907 case CKM_AES_CBC:

908 case CKM_DES_CBC:

909 case CKM_DES3_CBC:

910 case CKM_IDEA_CBC:

911 case CKM_CDMF_CBC:

912 case CKM_CAST_CBC:

913 case CKM_CAST3_CBC:

914 case CKM_CAST5_CBC:

915 case CKM_CAMELLIA_CBC_PAD:

916 case CKM_AES_CBC_PAD:

917 case CKM_DES_CBC_PAD:

918 case CKM_DES3_CBC_PAD:

919 case CKM_IDEA_CBC_PAD:

920 case CKM_CDMF_CBC_PAD:

921 case CKM_CAST_CBC_PAD:

922 case CKM_CAST3_CBC_PAD:

923 case CKM_CAST5_CBC_PAD:

924 case CKM_SKIPJACK_CBC64:

925 case CKM_SKIPJACK_ECB64:

926 case CKM_SKIPJACK_OFB64:

927 case CKM_SKIPJACK_CFB64:

928 case CKM_SKIPJACK_CFB32:

929 case CKM_SKIPJACK_CFB16:

930 case CKM_SKIPJACK_CFB8:

931 case CKM_BATON_ECB128:

932 case CKM_BATON_ECB96:

933 case CKM_BATON_CBC128:

934 case CKM_BATON_COUNTER:

935 case CKM_BATON_SHUFFLE:

936 case CKM_JUNIPER_ECB128:

937 case CKM_JUNIPER_CBC128:

938 case CKM_JUNIPER_COUNTER:

939 case CKM_JUNIPER_SHUFFLE:

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

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

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

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

944 param->len = iv->len;

945 }

946 break;

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

948 default:

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

950 break;

951 }

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

953 break;

954 }

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

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

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

958 param->len = iv->len;

959 }

960 break;

961 }

962 return param;

963 }

964

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

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

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

968 */

969 SECItem *

970 PK11_ParamFromIV(CK_MECHANISM_TYPE type,SECItem *iv)

971 {

972 return pk11_ParamFromIVWithLen(type, iv, 0);

973 }

974

975 unsigned char *

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

977 {

978 CK_RC2_CBC_PARAMS *rc2_params;

979 CK_RC5_CBC_PARAMS *rc5_cbc_params;

980

981 *len = 0;

982 switch (type) {

983 case CKM_SEED_ECB:

984 case CKM_CAMELLIA_ECB:

985 case CKM_AES_ECB:

986 case CKM_DES_ECB:

987 case CKM_DES3_ECB:

988 case CKM_RSA_PKCS:

989 case CKM_RSA_X_509:

990 case CKM_RSA_9796:

991 case CKM_IDEA_ECB:

992 case CKM_CDMF_ECB:

993 case CKM_CAST_ECB:

994 case CKM_CAST3_ECB:

995 case CKM_CAST5_ECB:

996 case CKM_RC4:

997 return NULL;

998 case CKM_RC2_ECB:

999 return NULL;

1000 case CKM_RC2_CBC:

1001 case CKM_RC2_CBC_PAD:

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

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

1004 return &rc2_params->iv[0];

1005 case CKM_RC5_CBC:

1006 case CKM_RC5_CBC_PAD:

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

1008 *len = rc5_cbc_params->ulIvLen;

1009 return rc5_cbc_params->pIv;

1010 case CKM_SEED_CBC:

1011 case CKM_CAMELLIA_CBC:

1012 case CKM_AES_CBC:

1013 case CKM_DES_CBC:

1014 case CKM_DES3_CBC:

1015 case CKM_IDEA_CBC:

1016 case CKM_CDMF_CBC:

1017 case CKM_CAST_CBC:

1018 case CKM_CAST3_CBC:

1019 case CKM_CAST5_CBC:

1020 case CKM_CAMELLIA_CBC_PAD:

1021 case CKM_AES_CBC_PAD:

1022 case CKM_DES_CBC_PAD:

1023 case CKM_DES3_CBC_PAD:

1024 case CKM_IDEA_CBC_PAD:

1025 case CKM_CDMF_CBC_PAD:

1026 case CKM_CAST_CBC_PAD:

1027 case CKM_CAST3_CBC_PAD:

1028 case CKM_CAST5_CBC_PAD:

1029 case CKM_SKIPJACK_CBC64:

1030 case CKM_SKIPJACK_ECB64:

1031 case CKM_SKIPJACK_OFB64:

1032 case CKM_SKIPJACK_CFB64:

1033 case CKM_SKIPJACK_CFB32:

1034 case CKM_SKIPJACK_CFB16:

1035 case CKM_SKIPJACK_CFB8:

1036 case CKM_BATON_ECB128:

1037 case CKM_BATON_ECB96:

1038 case CKM_BATON_CBC128:

1039 case CKM_BATON_COUNTER:

1040 case CKM_BATON_SHUFFLE:

1041 case CKM_JUNIPER_ECB128:

1042 case CKM_JUNIPER_CBC128:

1043 case CKM_JUNIPER_COUNTER:

1044 case CKM_JUNIPER_SHUFFLE:

1045 break;

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

1047 default:

1048 break;

1049 }

1050 if (param->data) {

1051 *len = param->len;

1052 }

1053 return param->data;

1054 }

1055

1056 typedef struct sec_rc5cbcParameterStr {

1057 SECItem version;

1058 SECItem rounds;

1059 SECItem blockSizeInBits;

1060 SECItem iv;

1061 } sec_rc5cbcParameter;

1062

1063 static const SEC_ASN1Template sec_rc5ecb_parameter_template[] = {

1064 { SEC_ASN1_SEQUENCE,

1065 0, NULL, sizeof(sec_rc5cbcParameter) },

1066 { SEC_ASN1_INTEGER,

1067 offsetof(sec_rc5cbcParameter,version) },

1068 { SEC_ASN1_INTEGER,

1069 offsetof(sec_rc5cbcParameter,rounds) },

1070 { SEC_ASN1_INTEGER,

1071 offsetof(sec_rc5cbcParameter,blockSizeInBits) },

1072 { 0 }

1073 };

1074

1075 static const SEC_ASN1Template sec_rc5cbc_parameter_template[] = {

1076 { SEC_ASN1_SEQUENCE,

1077 0, NULL, sizeof(sec_rc5cbcParameter) },

1078 { SEC_ASN1_INTEGER,

1079 offsetof(sec_rc5cbcParameter,version) },

1080 { SEC_ASN1_INTEGER,

1081 offsetof(sec_rc5cbcParameter,rounds) },

1082 { SEC_ASN1_INTEGER,

1083 offsetof(sec_rc5cbcParameter,blockSizeInBits) },

1084 { SEC_ASN1_OCTET_STRING,

1085 offsetof(sec_rc5cbcParameter,iv) },

1086 { 0 }

1087 };

1088

1089 typedef struct sec_rc2cbcParameterStr {

1090 SECItem rc2ParameterVersion;

1091 SECItem iv;

1092 } sec_rc2cbcParameter;

1093

1094 static const SEC_ASN1Template sec_rc2cbc_parameter_template[] = {

1095 { SEC_ASN1_SEQUENCE,

1096 0, NULL, sizeof(sec_rc2cbcParameter) },

1097 { SEC_ASN1_INTEGER,

1098 offsetof(sec_rc2cbcParameter,rc2ParameterVersion) },

1099 { SEC_ASN1_OCTET_STRING,

1100 offsetof(sec_rc2cbcParameter,iv) },

1101 { 0 }

1102 };

1103

1104 static const SEC_ASN1Template sec_rc2ecb_parameter_template[] = {

1105 { SEC_ASN1_SEQUENCE,

1106 0, NULL, sizeof(sec_rc2cbcParameter) },

1107 { SEC_ASN1_INTEGER,

1108 offsetof(sec_rc2cbcParameter,rc2ParameterVersion) },

1109 { 0 }

1110 };

1111

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

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

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

1115 static unsigned char rc2_map(SECItem *version)

1116 {

1117 long x;

1118

1119 x = DER_GetInteger(version);

1120

1121 switch (x) {

1122 case 58: return 128;

1123 case 120: return 64;

1124 case 160: return 40;

1125 }

1126 return 128;

1127 }

1128

1129 static unsigned long rc2_unmap(unsigned long x)

1130 {

1131 switch (x) {

1132 case 128: return 58;

1133 case 64: return 120;

1134 case 40: return 160;

1135 }

1136 return 58;

1137 }

1138

1139

1140

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

1142 SECItem *

1143 PK11_ParamFromAlgid(SECAlgorithmID *algid)

1144 {

1145 CK_RC2_CBC_PARAMS * rc2_cbc_params = NULL;

1146 CK_RC2_PARAMS * rc2_ecb_params = NULL;

1147 CK_RC5_CBC_PARAMS * rc5_cbc_params = NULL;

1148 CK_RC5_PARAMS * rc5_ecb_params = NULL;

1149 PLArenaPool * arena = NULL;

1150 SECItem * mech = NULL;

1151 SECOidTag algtag;

1152 SECStatus rv;

1153 CK_MECHANISM_TYPE type;

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

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

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

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

1158 {siBuffer, NULL, 0}, {siBuffer, NULL, 0} };

1159

1160 algtag = SECOID_GetAlgorithmTag(algid);

1161 type = PK11_AlgtagToMechanism(algtag);

1162

1163 mech = PORT_New(SECItem);

1164 if (mech == NULL) {

1165 return NULL;

1166 }

1167 mech->type = siBuffer;

1168 mech->data = NULL;

1169 mech->len = 0;

1170

1171 arena = PORT_NewArena(1024);

1172 if (!arena) {

1173 goto loser;

1174 }

1175

1176 /* handle the complicated cases */

1177 switch (type) {

1178 case CKM_RC2_ECB:

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

1180 &(algid->parameters));

1181 if (rv != SECSuccess) {

1182 goto loser;

1183 }

1184 rc2_ecb_params = PORT_New(CK_RC2_PARAMS);

1185 if (rc2_ecb_params == NULL) {

1186 goto loser;

1187 }

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

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

1190 mech->len = sizeof *rc2_ecb_params;

1191 break;

1192 case CKM_RC2_CBC:

1193 case CKM_RC2_CBC_PAD:

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

1195 &(algid->parameters));

1196 if (rv != SECSuccess) {

1197 goto loser;

1198 }

1199 rc2_cbc_params = PORT_New(CK_RC2_CBC_PARAMS);

1200 if (rc2_cbc_params == NULL) {

1201 goto loser;

1202 }

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

1204 mech->len = sizeof *rc2_cbc_params;

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

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

1207 PORT_SetError(SEC_ERROR_INPUT_LEN);

1208 goto loser;

1209 }

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

1211 break;

1212 case CKM_RC5_ECB:

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

1214 &(algid->parameters));

1215 if (rv != SECSuccess) {

1216 goto loser;

1217 }

1218 rc5_ecb_params = PORT_New(CK_RC5_PARAMS);

1219 if (rc5_ecb_params == NULL) {

1220 goto loser;

1221 }

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

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

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

1225 mech->len = sizeof *rc5_ecb_params;

1226 break;

1227 case CKM_RC5_CBC:

1228 case CKM_RC5_CBC_PAD:

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

1230 &(algid->parameters));

1231 if (rv != SECSuccess) {

1232 goto loser;

1233 }

1234 rc5_cbc_params = (CK_RC5_CBC_PARAMS *)

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

1236 if (rc5_cbc_params == NULL) {

1237 goto loser;

1238 }

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

1240 mech->len = sizeof *rc5_cbc_params;

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

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

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

1244 + sizeof(CK_RC5_CBC_PARAMS);

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

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

1247 break;

1248 case CKM_PBE_MD2_DES_CBC:

1249 case CKM_PBE_MD5_DES_CBC:

1250 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

1251 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

1252 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

1253 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

1254 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

1255 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

1256 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

1257 case CKM_PBE_SHA1_DES2_EDE_CBC:

1258 case CKM_PBE_SHA1_DES3_EDE_CBC:

1259 case CKM_PBE_SHA1_RC2_40_CBC:

1260 case CKM_PBE_SHA1_RC2_128_CBC:

1261 case CKM_PBE_SHA1_RC4_40:

1262 case CKM_PBE_SHA1_RC4_128:

1263 case CKM_PKCS5_PBKD2:

1264 rv = pbe_PK11AlgidToParam(algid,mech);

1265 if (rv != SECSuccess) {

1266 goto loser;

1267 }

1268 break;

1269 case CKM_RC4:

1270 case CKM_SEED_ECB:

1271 case CKM_CAMELLIA_ECB:

1272 case CKM_AES_ECB:

1273 case CKM_DES_ECB:

1274 case CKM_DES3_ECB:

1275 case CKM_IDEA_ECB:

1276 case CKM_CDMF_ECB:

1277 case CKM_CAST_ECB:

1278 case CKM_CAST3_ECB:

1279 case CKM_CAST5_ECB:

1280 break;

1281

1282 default:

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

1284 break;

1285 }

1286 /* FALL THROUGH */

1287 case CKM_SEED_CBC:

1288 case CKM_CAMELLIA_CBC:

1289 case CKM_AES_CBC:

1290 case CKM_DES_CBC:

1291 case CKM_DES3_CBC:

1292 case CKM_IDEA_CBC:

1293 case CKM_CDMF_CBC:

1294 case CKM_CAST_CBC:

1295 case CKM_CAST3_CBC:

1296 case CKM_CAST5_CBC:

1297 case CKM_SEED_CBC_PAD:

1298 case CKM_CAMELLIA_CBC_PAD:

1299 case CKM_AES_CBC_PAD:

1300 case CKM_DES_CBC_PAD:

1301 case CKM_DES3_CBC_PAD:

1302 case CKM_IDEA_CBC_PAD:

1303 case CKM_CDMF_CBC_PAD:

1304 case CKM_CAST_CBC_PAD:

1305 case CKM_CAST3_CBC_PAD:

1306 case CKM_CAST5_CBC_PAD:

1307 case CKM_SKIPJACK_CBC64:

1308 case CKM_SKIPJACK_ECB64:

1309 case CKM_SKIPJACK_OFB64:

1310 case CKM_SKIPJACK_CFB64:

1311 case CKM_SKIPJACK_CFB32:

1312 case CKM_SKIPJACK_CFB16:

1313 case CKM_SKIPJACK_CFB8:

1314 case CKM_BATON_ECB128:

1315 case CKM_BATON_ECB96:

1316 case CKM_BATON_CBC128:

1317 case CKM_BATON_COUNTER:

1318 case CKM_BATON_SHUFFLE:

1319 case CKM_JUNIPER_ECB128:

1320 case CKM_JUNIPER_CBC128:

1321 case CKM_JUNIPER_COUNTER:

1322 case CKM_JUNIPER_SHUFFLE:

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

1324 rv = SEC_ASN1DecodeItem(arena, &iv,

1325 SEC_ASN1_GET(SEC_OctetStringTemplate),

1326 &(algid->parameters));

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

1328 goto loser;

1329 }

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

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

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

1333 goto loser;

1334 }

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

1336 mech->len = iv.len;

1337 break;

1338 }

1339 PORT_FreeArena(arena, PR_FALSE);

1340 return mech;

1341

1342 loser:

1343 if (arena)

1344 PORT_FreeArena(arena, PR_FALSE);

1345 SECITEM_FreeItem(mech,PR_TRUE);

1346 return NULL;

1347 }

1348

1349 /*

1350 * Generate an IV for the given mechanism

1351 */

1352 static SECStatus

1353 pk11_GenIV(CK_MECHANISM_TYPE type, SECItem *iv) {

1354 int iv_size = PK11_GetIVLength(type);

1355 SECStatus rv;

1356

1357 iv->len = iv_size;

1358 if (iv_size == 0) {

1359 iv->data = NULL;

1360 return SECSuccess;

1361 }

1362

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

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

1365 iv->len = 0;

1366 return SECFailure;

1367 }

1368

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

1370 if (rv != SECSuccess) {

1371 PORT_Free(iv->data);

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

1373 return SECFailure;

1374 }

1375 return SECSuccess;

1376 }

1377

1378

1379 /*

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

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

1382 */

1383 SECItem *

1384 pk11_GenerateNewParamWithKeyLen(CK_MECHANISM_TYPE type, int keyLen)

1385 {

1386 CK_RC2_CBC_PARAMS *rc2_params;

1387 CK_RC2_PARAMS *rc2_ecb_params;

1388 SECItem *mech;

1389 SECItem iv;

1390 SECStatus rv;

1391

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

1393 if (mech == NULL) return NULL;

1394

1395 rv = SECSuccess;

1396 mech->type = siBuffer;

1397 mech->data = NULL;

1398 mech->len = 0;

1399 switch (type) {

1400 case CKM_RC4:

1401 case CKM_SEED_ECB:

1402 case CKM_CAMELLIA_ECB:

1403 case CKM_AES_ECB:

1404 case CKM_DES_ECB:

1405 case CKM_DES3_ECB:

1406 case CKM_IDEA_ECB:

1407 case CKM_CDMF_ECB:

1408 case CKM_CAST_ECB:

1409 case CKM_CAST3_ECB:

1410 case CKM_CAST5_ECB:

1411 break;

1412 case CKM_RC2_ECB:

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

1414 if (rc2_ecb_params == NULL) {

1415 rv = SECFailure;

1416 break;

1417 }

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

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

1420 rc2_ecb_params = keyLen ? keyLen8 : 128;

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

1422 mech->len = sizeof(CK_RC2_PARAMS);

1423 break;

1424 case CKM_RC2_CBC:

1425 case CKM_RC2_CBC_PAD:

1426 rv = pk11_GenIV(type,&iv);

1427 if (rv != SECSuccess) {

1428 break;

1429 }

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

1431 if (rc2_params == NULL) {

1432 PORT_Free(iv.data);

1433 rv = SECFailure;

1434 break;

1435 }

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

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

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

1439 if (iv.data)

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

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

1442 mech->len = sizeof(CK_RC2_CBC_PARAMS);

1443 PORT_Free(iv.data);

1444 break;

1445 case CKM_RC5_ECB:

1446 PORT_Free(mech);

1447 return PK11_ParamFromIV(type,NULL);

1448 case CKM_RC5_CBC:

1449 case CKM_RC5_CBC_PAD:

1450 rv = pk11_GenIV(type,&iv);

1451 if (rv != SECSuccess) {

1452 break;

1453 }

1454 PORT_Free(mech);

1455 return PK11_ParamFromIV(type,&iv);

1456 default:

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

1458 break;

1459 }

1460 case CKM_SEED_CBC:

1461 case CKM_CAMELLIA_CBC:

1462 case CKM_AES_CBC:

1463 case CKM_DES_CBC:

1464 case CKM_DES3_CBC:

1465 case CKM_IDEA_CBC:

1466 case CKM_CDMF_CBC:

1467 case CKM_CAST_CBC:

1468 case CKM_CAST3_CBC:

1469 case CKM_CAST5_CBC:

1470 case CKM_DES_CBC_PAD:

1471 case CKM_DES3_CBC_PAD:

1472 case CKM_IDEA_CBC_PAD:

1473 case CKM_CDMF_CBC_PAD:

1474 case CKM_CAST_CBC_PAD:

1475 case CKM_CAST3_CBC_PAD:

1476 case CKM_CAST5_CBC_PAD:

1477 case CKM_SKIPJACK_CBC64:

1478 case CKM_SKIPJACK_ECB64:

1479 case CKM_SKIPJACK_OFB64:

1480 case CKM_SKIPJACK_CFB64:

1481 case CKM_SKIPJACK_CFB32:

1482 case CKM_SKIPJACK_CFB16:

1483 case CKM_SKIPJACK_CFB8:

1484 case CKM_BATON_ECB128:

1485 case CKM_BATON_ECB96:

1486 case CKM_BATON_CBC128:

1487 case CKM_BATON_COUNTER:

1488 case CKM_BATON_SHUFFLE:

1489 case CKM_JUNIPER_ECB128:

1490 case CKM_JUNIPER_CBC128:

1491 case CKM_JUNIPER_COUNTER:

1492 case CKM_JUNIPER_SHUFFLE:

1493 rv = pk11_GenIV(type,&iv);

1494 if (rv != SECSuccess) {

1495 break;

1496 }

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

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

1499 PORT_Free(iv.data);

1500 rv = SECFailure;

1501 break;

1502 }

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

1504 mech->len = iv.len;

1505 PORT_Free(iv.data);

1506 break;

1507 }

1508 if (rv != SECSuccess) {

1509 SECITEM_FreeItem(mech,PR_TRUE);

1510 return NULL;

1511 }

1512 return mech;

1513

1514 }

1515

1516 SECItem *

1517 PK11_GenerateNewParam(CK_MECHANISM_TYPE type, PK11SymKey *key)

1518 {

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

1520

1521 return pk11_GenerateNewParamWithKeyLen(type, keyLen);

1522 }

1523

1524 #define RC5_V10 0x10

1525

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

1527 SECStatus

1528 PK11_ParamToAlgid(SECOidTag algTag, SECItem *param,

1529 PLArenaPool arena, SECAlgorithmID algid) {

1530 CK_RC2_CBC_PARAMS *rc2_params;

1531 sec_rc2cbcParameter rc2;

1532 CK_RC5_CBC_PARAMS *rc5_params;

1533 sec_rc5cbcParameter rc5;

1534 CK_MECHANISM_TYPE type = PK11_AlgtagToMechanism(algTag);

1535 SECItem *newParams = NULL;

1536 SECStatus rv = SECFailure;

1537 unsigned long rc2version;

1538

1539 switch (type) {

1540 case CKM_RC4:

1541 case CKM_SEED_ECB:

1542 case CKM_CAMELLIA_ECB:

1543 case CKM_AES_ECB:

1544 case CKM_DES_ECB:

1545 case CKM_DES3_ECB:

1546 case CKM_IDEA_ECB:

1547 case CKM_CDMF_ECB:

1548 case CKM_CAST_ECB:

1549 case CKM_CAST3_ECB:

1550 case CKM_CAST5_ECB:

1551 newParams = NULL;

1552 rv = SECSuccess;

1553 break;

1554 case CKM_RC2_ECB:

1555 break;

1556 case CKM_RC2_CBC:

1557 case CKM_RC2_CBC_PAD:

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

1559 rc2version = rc2_unmap(rc2_params->ulEffectiveBits);

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

1561 rc2version) == NULL)

1562 break;

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

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

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

1566 sec_rc2cbc_parameter_template);

1567 PORT_Free(rc2.rc2ParameterVersion.data);

1568 if (newParams == NULL)

1569 break;

1570 rv = SECSuccess;

1571 break;

1572

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

1574 break;

1575 case CKM_RC5_CBC:

1576 case CKM_RC5_CBC_PAD:

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

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

1579 break;

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

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

1582 PORT_Free(rc5.version.data);

1583 break;

1584 }

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

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

1587 PORT_Free(rc5.blockSizeInBits.data);

1588 PORT_Free(rc5.version.data);

1589 break;

1590 }

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

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

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

1594 sec_rc5cbc_parameter_template);

1595 PORT_Free(rc5.version.data);

1596 PORT_Free(rc5.blockSizeInBits.data);

1597 PORT_Free(rc5.rounds.data);

1598 if (newParams == NULL)

1599 break;

1600 rv = SECSuccess;

1601 break;

1602 case CKM_PBE_MD2_DES_CBC:

1603 case CKM_PBE_MD5_DES_CBC:

1604 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

1605 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

1606 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

1607 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

1608 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

1609 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

1610 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

1611 case CKM_PBE_SHA1_DES3_EDE_CBC:

1612 case CKM_PBE_SHA1_DES2_EDE_CBC:

1613 case CKM_PBE_SHA1_RC2_40_CBC:

1614 case CKM_PBE_SHA1_RC2_128_CBC:

1615 case CKM_PBE_SHA1_RC4_40:

1616 case CKM_PBE_SHA1_RC4_128:

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

1618 default:

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

1620 rv = SECSuccess;

1621 newParams = NULL;

1622 break;

1623 }

1624 case CKM_SEED_CBC:

1625 case CKM_CAMELLIA_CBC:

1626 case CKM_AES_CBC:

1627 case CKM_DES_CBC:

1628 case CKM_DES3_CBC:

1629 case CKM_IDEA_CBC:

1630 case CKM_CDMF_CBC:

1631 case CKM_CAST_CBC:

1632 case CKM_CAST3_CBC:

1633 case CKM_CAST5_CBC:

1634 case CKM_DES_CBC_PAD:

1635 case CKM_DES3_CBC_PAD:

1636 case CKM_IDEA_CBC_PAD:

1637 case CKM_CDMF_CBC_PAD:

1638 case CKM_CAST_CBC_PAD:

1639 case CKM_CAST3_CBC_PAD:

1640 case CKM_CAST5_CBC_PAD:

1641 case CKM_SKIPJACK_CBC64:

1642 case CKM_SKIPJACK_ECB64:

1643 case CKM_SKIPJACK_OFB64:

1644 case CKM_SKIPJACK_CFB64:

1645 case CKM_SKIPJACK_CFB32:

1646 case CKM_SKIPJACK_CFB16:

1647 case CKM_SKIPJACK_CFB8:

1648 case CKM_BATON_ECB128:

1649 case CKM_BATON_ECB96:

1650 case CKM_BATON_CBC128:

1651 case CKM_BATON_COUNTER:

1652 case CKM_BATON_SHUFFLE:

1653 case CKM_JUNIPER_ECB128:

1654 case CKM_JUNIPER_CBC128:

1655 case CKM_JUNIPER_COUNTER:

1656 case CKM_JUNIPER_SHUFFLE:

1657 newParams = SEC_ASN1EncodeItem(NULL,NULL,param,

1658 SEC_ASN1_GET(SEC_OctetStringTemplate) );

1659 if (newParams == NULL)

1660 break;

1661 rv = SECSuccess;

1662 break;

1663 }

1664

1665 if (rv != SECSuccess) {

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

1667 return rv;

1668 }

1669

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

1671 SECITEM_FreeItem(newParams,PR_TRUE);

1672 return rv;

1673 }

1674

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

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

1677 * this mapping in our standard OID table */

1678 CK_MECHANISM_TYPE

1679 PK11_AlgtagToMechanism(SECOidTag algTag) {

1680 SECOidData *oid = SECOID_FindOIDByTag(algTag);

1681

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

1683 return CKM_INVALID_MECHANISM;

1684 }

1685

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

1687 SECOidTag

1688 PK11_MechanismToAlgtag(CK_MECHANISM_TYPE type) {

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

1690

1691 if (oid) return oid->offset;

1692 return SEC_OID_UNKNOWN;

1693 }

1694

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

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

1697 * mechanism, we simply return the mechanism.

1698 */

1699 CK_MECHANISM_TYPE

1700 PK11_GetPadMechanism(CK_MECHANISM_TYPE type) {

1701 switch(type) {

1702 case CKM_SEED_CBC:

1703 return CKM_SEED_CBC_PAD;

1704 case CKM_CAMELLIA_CBC:

1705 return CKM_CAMELLIA_CBC_PAD;

1706 case CKM_AES_CBC:

1707 return CKM_AES_CBC_PAD;

1708 case CKM_DES_CBC:

1709 return CKM_DES_CBC_PAD;

1710 case CKM_DES3_CBC:

1711 return CKM_DES3_CBC_PAD;

1712 case CKM_RC2_CBC:

1713 return CKM_RC2_CBC_PAD;

1714 case CKM_CDMF_CBC:

1715 return CKM_CDMF_CBC_PAD;

1716 case CKM_CAST_CBC:

1717 return CKM_CAST_CBC_PAD;

1718 case CKM_CAST3_CBC:

1719 return CKM_CAST3_CBC_PAD;

1720 case CKM_CAST5_CBC:

1721 return CKM_CAST5_CBC_PAD;

1722 case CKM_RC5_CBC:

1723 return CKM_RC5_CBC_PAD;

1724 case CKM_IDEA_CBC:

1725 return CKM_IDEA_CBC_PAD;

1726 default:

1727 break;

1728 }

1729

1730 return type;

1731 }

1732

1733 static PRBool

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

1735 while (len--) {

1736 if (*data++) {

1737 return PR_FALSE;

1738 }

1739 }

1740 return PR_TRUE;

1741 }

1742

1743 CK_RV

1744 PK11_MapPBEMechanismToCryptoMechanism(CK_MECHANISM_PTR pPBEMechanism,

1745 CK_MECHANISM_PTR pCryptoMechanism,

1746 SECItem *pbe_pwd, PRBool faulty3DES)

1747 {

1748 int iv_len = 0;

1749 CK_PBE_PARAMS_PTR pPBEparams;

1750 CK_RC2_CBC_PARAMS_PTR rc2_params;

1751 CK_ULONG rc2_key_len;

1752

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

1754 return CKR_HOST_MEMORY;

1755 }

1756

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

1758 * use PK11_GetPBECryptoMechanism instead.

1759 */

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

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

1762 return CKR_MECHANISM_INVALID;

1763 }

1764

1765 pPBEparams = (CK_PBE_PARAMS_PTR)pPBEMechanism->pParameter;

1766 iv_len = PK11_GetIVLength(pPBEMechanism->mechanism);

1767

1768 if (iv_len) {

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

1770 SECItem param;

1771 PK11SymKey *symKey;

1772 PK11SlotInfo *intSlot = PK11_GetInternalSlot();

1773

1774 if (intSlot == NULL) {

1775 return CKR_DEVICE_ERROR;

1776 }

1777

1778 param.data = pPBEMechanism->pParameter;

1779 param.len = pPBEMechanism->ulParameterLen;

1780

1781 symKey = PK11_RawPBEKeyGen(intSlot,

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

1783 PK11_FreeSlot(intSlot);

1784 if (symKey== NULL) {

1785 return CKR_DEVICE_ERROR; /* sigh */

1786 }

1787 PK11_FreeSymKey(symKey);

1788 }

1789 }

1790

1791 switch(pPBEMechanism->mechanism) {

1792 case CKM_PBE_MD2_DES_CBC:

1793 case CKM_PBE_MD5_DES_CBC:

1794 case CKM_NETSCAPE_PBE_SHA1_DES_CBC:

1795 pCryptoMechanism->mechanism = CKM_DES_CBC;

1796 goto have_crypto_mechanism;

1797 case CKM_NETSCAPE_PBE_SHA1_TRIPLE_DES_CBC:

1798 case CKM_NETSCAPE_PBE_SHA1_FAULTY_3DES_CBC:

1799 case CKM_PBE_SHA1_DES3_EDE_CBC:

1800 case CKM_PBE_SHA1_DES2_EDE_CBC:

1801 pCryptoMechanism->mechanism = CKM_DES3_CBC;

1802 have_crypto_mechanism:

1803 pCryptoMechanism->pParameter = PORT_Alloc(iv_len);

1804 pCryptoMechanism->ulParameterLen = (CK_ULONG)iv_len;

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

1806 return CKR_HOST_MEMORY;

1807 }

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

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

1810 iv_len);

1811 break;

1812 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC4:

1813 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC4:

1814 case CKM_PBE_SHA1_RC4_40:

1815 case CKM_PBE_SHA1_RC4_128:

1816 pCryptoMechanism->mechanism = CKM_RC4;

1817 pCryptoMechanism->ulParameterLen = 0;

1818 pCryptoMechanism->pParameter = CK_NULL_PTR;

1819 break;

1820 case CKM_NETSCAPE_PBE_SHA1_40_BIT_RC2_CBC:

1821 case CKM_PBE_SHA1_RC2_40_CBC:

1822 rc2_key_len = 40;

1823 goto have_key_len;

1824 case CKM_NETSCAPE_PBE_SHA1_128_BIT_RC2_CBC:

1825 rc2_key_len = 128;

1826 have_key_len:

1827 pCryptoMechanism->mechanism = CKM_RC2_CBC;

1828 pCryptoMechanism->ulParameterLen = (CK_ULONG)

1829 sizeof(CK_RC2_CBC_PARAMS);

1830 pCryptoMechanism->pParameter = (CK_RC2_CBC_PARAMS_PTR)

1831 PORT_ZAlloc(sizeof(CK_RC2_CBC_PARAMS));

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

1833 return CKR_HOST_MEMORY;

1834 }

1835 rc2_params = (CK_RC2_CBC_PARAMS_PTR)pCryptoMechanism->pParameter;

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

1837 (unsigned char *)pPBEparams->pInitVector,

1838 iv_len);

1839 rc2_params->ulEffectiveBits = rc2_key_len;

1840 break;

1841 default:

1842 return CKR_MECHANISM_INVALID;

1843 }

1844

1845 return CKR_OK;

1846 }

1847

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

1849 CK_MECHANISM_TYPE

1850 PK11_MapSignKeyType(KeyType keyType)

1851 {

1852 switch (keyType) {

1853 case rsaKey:

1854 return CKM_RSA_PKCS;

1855 case fortezzaKey:

1856 case dsaKey:

1857 return CKM_DSA;

1858 case ecKey:

1859 return CKM_ECDSA;

1860 case dhKey:

1861 default:

1862 break;

1863 }

1864 return CKM_INVALID_MECHANISM;

1865 }

1866

1867 CK_MECHANISM_TYPE

1868 pk11_mapWrapKeyType(KeyType keyType)

1869 {

1870 switch (keyType) {

1871 case rsaKey:

1872 return CKM_RSA_PKCS;

1873 /* Add fortezza?? */

1874 default:

1875 break;

1876 }

1877 return CKM_INVALID_MECHANISM;

1878 }

1879

1880 SECOidTag

1881 PK11_FortezzaMapSig(SECOidTag algTag)

1882 {

1883 switch (algTag) {

1884 case SEC_OID_MISSI_KEA_DSS:

1885 case SEC_OID_MISSI_DSS:

1886 case SEC_OID_MISSI_DSS_OLD:

1887 case SEC_OID_MISSI_KEA_DSS_OLD:

1888 case SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST:

1889 return SEC_OID_ANSIX9_DSA_SIGNATURE;

1890 default:

1891 break;

1892 }

1893 return algTag;

1894 }

OLD	NEW

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