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