Print this page
6723237 libcryptoutil should allow mechanism number "0x80000000" (the value of marker CKM_VENDOR_DEFINED)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libcryptoutil/common/mechstr.c
+++ new/usr/src/lib/libcryptoutil/common/mechstr.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 -#pragma ident "@(#)mechstr.c 1.7 08/07/01 SMI"
26 +#pragma ident "@(#)mechstr.c 1.8 08/07/07 SMI"
27 27
28 28 /*
29 29 * Convert Algorithm names as strings to PKCS#11 Mech numbers and vice versa.
30 30 */
31 31
32 32 #include <limits.h>
33 33 #include <string.h>
34 34 #include <stdlib.h>
35 35 #include <stdio.h>
36 36 #include <security/cryptoki.h>
37 37 #include <security/pkcs11t.h>
38 38
39 39 #include <cryptoutil.h>
40 40
41 41 /*
42 42 * This table is a one-to-one mapping between mechanism names and numbers.
43 43 * As such, it should not contain deprecated mechanism names (aliases).
44 44 */
45 45 typedef struct {
46 46 const char *str;
47 47 CK_MECHANISM_TYPE mech;
48 48 } pkcs11_mapping_t;
49 49
50 50 /*
51 51 * Note: elements in this table MUST be in numeric order,
52 52 * since bsearch(3C) is used to search this table.
53 53 */
54 54 static const pkcs11_mapping_t mapping[] = {
55 55 { "CKM_RSA_PKCS_KEY_PAIR_GEN", CKM_RSA_PKCS_KEY_PAIR_GEN },
56 56 { "CKM_RSA_PKCS", CKM_RSA_PKCS },
57 57 { "CKM_RSA_9796", CKM_RSA_9796 },
58 58 { "CKM_RSA_X_509", CKM_RSA_X_509 },
59 59 { "CKM_MD2_RSA_PKCS", CKM_MD2_RSA_PKCS },
60 60 { "CKM_MD5_RSA_PKCS", CKM_MD5_RSA_PKCS },
61 61 { "CKM_SHA1_RSA_PKCS", CKM_SHA1_RSA_PKCS },
62 62 { "CKM_RIPEMD128_RSA_PKCS", CKM_RIPEMD128_RSA_PKCS },
63 63 { "CKM_RIPEMD160_RSA_PKCS", CKM_RIPEMD160_RSA_PKCS },
64 64 { "CKM_RSA_PKCS_OAEP", CKM_RSA_PKCS_OAEP },
65 65 { "CKM_RSA_X9_31_KEY_PAIR_GEN", CKM_RSA_X9_31_KEY_PAIR_GEN },
66 66 { "CKM_RSA_X9_31", CKM_RSA_X9_31 },
67 67 { "CKM_SHA1_RSA_X9_31", CKM_SHA1_RSA_X9_31 },
68 68 { "CKM_RSA_PKCS_PSS", CKM_RSA_PKCS_PSS },
69 69 { "CKM_SHA1_RSA_PKCS_PSS", CKM_SHA1_RSA_PKCS_PSS },
70 70 { "CKM_DSA_KEY_PAIR_GEN", CKM_DSA_KEY_PAIR_GEN },
71 71 { "CKM_DSA", CKM_DSA },
72 72 { "CKM_DSA_SHA1", CKM_DSA_SHA1 },
73 73 { "CKM_DH_PKCS_KEY_PAIR_GEN", CKM_DH_PKCS_KEY_PAIR_GEN },
74 74 { "CKM_DH_PKCS_DERIVE", CKM_DH_PKCS_DERIVE },
75 75 { "CKM_X9_42_DH_KEY_PAIR_GEN", CKM_X9_42_DH_KEY_PAIR_GEN },
76 76 { "CKM_X9_42_DH_DERIVE", CKM_X9_42_DH_DERIVE },
77 77 { "CKM_X9_42_DH_HYBRID_DERIVE", CKM_X9_42_DH_HYBRID_DERIVE },
78 78 { "CKM_X9_42_MQV_DERIVE", CKM_X9_42_MQV_DERIVE },
79 79 { "CKM_SHA256_RSA_PKCS", CKM_SHA256_RSA_PKCS },
80 80 { "CKM_SHA384_RSA_PKCS", CKM_SHA384_RSA_PKCS },
81 81 { "CKM_SHA512_RSA_PKCS", CKM_SHA512_RSA_PKCS },
82 82 { "CKM_SHA256_RSA_PKCS_PSS", CKM_SHA256_RSA_PKCS_PSS },
83 83 { "CKM_SHA384_RSA_PKCS_PSS", CKM_SHA384_RSA_PKCS_PSS },
84 84 { "CKM_SHA512_RSA_PKCS_PSS", CKM_SHA512_RSA_PKCS_PSS },
85 85 { "CKM_SHA224_RSA_PKCS", CKM_SHA224_RSA_PKCS },
86 86 { "CKM_SHA224_RSA_PKCS_PSS", CKM_SHA224_RSA_PKCS_PSS },
87 87 { "CKM_RC2_KEY_GEN", CKM_RC2_KEY_GEN },
88 88 { "CKM_RC2_ECB", CKM_RC2_ECB },
89 89 { "CKM_RC2_CBC", CKM_RC2_CBC },
90 90 { "CKM_RC2_MAC", CKM_RC2_MAC },
91 91 { "CKM_RC2_MAC_GENERAL", CKM_RC2_MAC_GENERAL },
92 92 { "CKM_RC2_CBC_PAD", CKM_RC2_CBC_PAD },
93 93 { "CKM_RC4_KEY_GEN", CKM_RC4_KEY_GEN },
94 94 { "CKM_RC4", CKM_RC4 },
95 95 { "CKM_DES_KEY_GEN", CKM_DES_KEY_GEN },
96 96 { "CKM_DES_ECB", CKM_DES_ECB },
97 97 { "CKM_DES_CBC", CKM_DES_CBC },
98 98 { "CKM_DES_MAC", CKM_DES_MAC },
99 99 { "CKM_DES_MAC_GENERAL", CKM_DES_MAC_GENERAL },
100 100 { "CKM_DES_CBC_PAD", CKM_DES_CBC_PAD },
101 101 { "CKM_DES2_KEY_GEN", CKM_DES2_KEY_GEN },
102 102 { "CKM_DES3_KEY_GEN", CKM_DES3_KEY_GEN },
103 103 { "CKM_DES3_ECB", CKM_DES3_ECB },
104 104 { "CKM_DES3_CBC", CKM_DES3_CBC },
105 105 { "CKM_DES3_MAC", CKM_DES3_MAC },
106 106 { "CKM_DES3_MAC_GENERAL", CKM_DES3_MAC_GENERAL },
107 107 { "CKM_DES3_CBC_PAD", CKM_DES3_CBC_PAD },
108 108 { "CKM_CDMF_KEY_GEN", CKM_CDMF_KEY_GEN },
109 109 { "CKM_CDMF_ECB", CKM_CDMF_ECB },
110 110 { "CKM_CDMF_CBC", CKM_CDMF_CBC },
111 111 { "CKM_CDMF_MAC", CKM_CDMF_MAC },
112 112 { "CKM_CDMF_MAC_GENERAL", CKM_CDMF_MAC_GENERAL },
113 113 { "CKM_CDMF_CBC_PAD", CKM_CDMF_CBC_PAD },
114 114 { "CKM_DES_OFB64", CKM_DES_OFB64 },
115 115 { "CKM_DES_OFB8", CKM_DES_OFB8 },
116 116 { "CKM_DES_CFB64", CKM_DES_CFB64 },
117 117 { "CKM_DES_CFB8", CKM_DES_CFB8 },
118 118 { "CKM_MD2", CKM_MD2 },
119 119 { "CKM_MD2_HMAC", CKM_MD2_HMAC },
120 120 { "CKM_MD2_HMAC_GENERAL", CKM_MD2_HMAC_GENERAL },
121 121 { "CKM_MD5", CKM_MD5 },
122 122 { "CKM_MD5_HMAC", CKM_MD5_HMAC },
123 123 { "CKM_MD5_HMAC_GENERAL", CKM_MD5_HMAC_GENERAL },
124 124 { "CKM_SHA_1", CKM_SHA_1 },
125 125 { "CKM_SHA_1_HMAC", CKM_SHA_1_HMAC },
126 126 { "CKM_SHA_1_HMAC_GENERAL", CKM_SHA_1_HMAC_GENERAL },
127 127 { "CKM_RIPEMD128", CKM_RIPEMD128 },
128 128 { "CKM_RIPEMD128_HMAC", CKM_RIPEMD128_HMAC },
129 129 { "CKM_RIPEMD128_HMAC_GENERAL", CKM_RIPEMD128_HMAC_GENERAL },
130 130 { "CKM_RIPEMD160", CKM_RIPEMD160 },
131 131 { "CKM_RIPEMD160_HMAC", CKM_RIPEMD160_HMAC },
132 132 { "CKM_RIPEMD160_HMAC_GENERAL", CKM_RIPEMD160_HMAC_GENERAL },
133 133 { "CKM_SHA256", CKM_SHA256 },
134 134 { "CKM_SHA256_HMAC", CKM_SHA256_HMAC },
135 135 { "CKM_SHA256_HMAC_GENERAL", CKM_SHA256_HMAC_GENERAL },
136 136 { "CKM_SHA224", CKM_SHA224 },
137 137 { "CKM_SHA224_HMAC", CKM_SHA224_HMAC },
138 138 { "CKM_SHA224_HMAC_GENERAL", CKM_SHA224_HMAC_GENERAL },
139 139 { "CKM_SHA384", CKM_SHA384 },
140 140 { "CKM_SHA384_HMAC", CKM_SHA384_HMAC },
141 141 { "CKM_SHA384_HMAC_GENERAL", CKM_SHA384_HMAC_GENERAL },
142 142 { "CKM_SHA512", CKM_SHA512 },
143 143 { "CKM_SHA512_HMAC", CKM_SHA512_HMAC },
144 144 { "CKM_SHA512_HMAC_GENERAL", CKM_SHA512_HMAC_GENERAL },
145 145 { "CKM_SECURID_KEY_GEN", CKM_SECURID_KEY_GEN },
146 146 { "CKM_SECURID", CKM_SECURID },
147 147 { "CKM_HOTP_KEY_GEN", CKM_HOTP_KEY_GEN },
148 148 { "CKM_HOTP", CKM_HOTP },
149 149 { "CKM_ACTI", CKM_ACTI },
150 150 { "CKM_ACTI_KEY_GEN", CKM_ACTI_KEY_GEN },
151 151 { "CKM_CAST_KEY_GEN", CKM_CAST_KEY_GEN },
152 152 { "CKM_CAST_ECB", CKM_CAST_ECB },
153 153 { "CKM_CAST_CBC", CKM_CAST_CBC },
154 154 { "CKM_CAST_MAC", CKM_CAST_MAC },
155 155 { "CKM_CAST_MAC_GENERAL", CKM_CAST_MAC_GENERAL },
156 156 { "CKM_CAST_CBC_PAD", CKM_CAST_CBC_PAD },
157 157 { "CKM_CAST3_KEY_GEN", CKM_CAST3_KEY_GEN },
158 158 { "CKM_CAST3_ECB", CKM_CAST3_ECB },
159 159 { "CKM_CAST3_CBC", CKM_CAST3_CBC },
160 160 { "CKM_CAST3_MAC", CKM_CAST3_MAC },
161 161 { "CKM_CAST3_MAC_GENERAL", CKM_CAST3_MAC_GENERAL },
162 162 { "CKM_CAST3_CBC_PAD", CKM_CAST3_CBC_PAD },
163 163 { "CKM_CAST5_KEY_GEN", CKM_CAST5_KEY_GEN },
164 164 { "CKM_CAST128_KEY_GEN", CKM_CAST128_KEY_GEN },
165 165 { "CKM_CAST5_ECB", CKM_CAST5_ECB },
166 166 { "CKM_CAST128_ECB", CKM_CAST128_ECB },
167 167 { "CKM_CAST5_CBC", CKM_CAST5_CBC },
168 168 { "CKM_CAST128_CBC", CKM_CAST128_CBC },
169 169 { "CKM_CAST5_MAC", CKM_CAST5_MAC },
170 170 { "CKM_CAST128_MAC", CKM_CAST128_MAC },
171 171 { "CKM_CAST5_MAC_GENERAL", CKM_CAST5_MAC_GENERAL },
172 172 { "CKM_CAST128_MAC_GENERAL", CKM_CAST128_MAC_GENERAL },
173 173 { "CKM_CAST5_CBC_PAD", CKM_CAST5_CBC_PAD },
174 174 { "CKM_CAST128_CBC_PAD", CKM_CAST128_CBC_PAD },
175 175 { "CKM_RC5_KEY_GEN", CKM_RC5_KEY_GEN },
176 176 { "CKM_RC5_ECB", CKM_RC5_ECB },
177 177 { "CKM_RC5_CBC", CKM_RC5_CBC },
178 178 { "CKM_RC5_MAC", CKM_RC5_MAC },
179 179 { "CKM_RC5_MAC_GENERAL", CKM_RC5_MAC_GENERAL },
180 180 { "CKM_RC5_CBC_PAD", CKM_RC5_CBC_PAD },
181 181 { "CKM_IDEA_KEY_GEN", CKM_IDEA_KEY_GEN },
182 182 { "CKM_IDEA_ECB", CKM_IDEA_ECB },
183 183 { "CKM_IDEA_CBC", CKM_IDEA_CBC },
184 184 { "CKM_IDEA_MAC", CKM_IDEA_MAC },
185 185 { "CKM_IDEA_MAC_GENERAL", CKM_IDEA_MAC_GENERAL },
186 186 { "CKM_IDEA_CBC_PAD", CKM_IDEA_CBC_PAD },
187 187 { "CKM_GENERIC_SECRET_KEY_GEN", CKM_GENERIC_SECRET_KEY_GEN },
188 188 { "CKM_CONCATENATE_BASE_AND_KEY", CKM_CONCATENATE_BASE_AND_KEY },
189 189 { "CKM_CONCATENATE_BASE_AND_DATA", CKM_CONCATENATE_BASE_AND_DATA },
190 190 { "CKM_CONCATENATE_DATA_AND_BASE", CKM_CONCATENATE_DATA_AND_BASE },
191 191 { "CKM_XOR_BASE_AND_DATA", CKM_XOR_BASE_AND_DATA },
192 192 { "CKM_EXTRACT_KEY_FROM_KEY", CKM_EXTRACT_KEY_FROM_KEY },
193 193 { "CKM_SSL3_PRE_MASTER_KEY_GEN", CKM_SSL3_PRE_MASTER_KEY_GEN },
194 194 { "CKM_SSL3_MASTER_KEY_DERIVE", CKM_SSL3_MASTER_KEY_DERIVE },
195 195 { "CKM_SSL3_KEY_AND_MAC_DERIVE", CKM_SSL3_KEY_AND_MAC_DERIVE },
196 196 { "CKM_SSL3_MASTER_KEY_DERIVE_DH", CKM_SSL3_MASTER_KEY_DERIVE_DH },
197 197 { "CKM_TLS_PRE_MASTER_KEY_GEN", CKM_TLS_PRE_MASTER_KEY_GEN },
198 198 { "CKM_TLS_MASTER_KEY_DERIVE", CKM_TLS_MASTER_KEY_DERIVE },
199 199 { "CKM_TLS_KEY_AND_MAC_DERIVE", CKM_TLS_KEY_AND_MAC_DERIVE },
200 200 { "CKM_TLS_MASTER_KEY_DERIVE_DH", CKM_TLS_MASTER_KEY_DERIVE_DH },
201 201 { "CKM_TLS_PRF", CKM_TLS_PRF },
202 202 { "CKM_SSL3_MD5_MAC", CKM_SSL3_MD5_MAC },
203 203 { "CKM_SSL3_SHA1_MAC", CKM_SSL3_SHA1_MAC },
204 204 { "CKM_MD5_KEY_DERIVATION", CKM_MD5_KEY_DERIVATION },
205 205 { "CKM_MD2_KEY_DERIVATION", CKM_MD2_KEY_DERIVATION },
206 206 { "CKM_SHA1_KEY_DERIVATION", CKM_SHA1_KEY_DERIVATION },
207 207 { "CKM_SHA256_KEY_DERIVATION", CKM_SHA256_KEY_DERIVATION },
208 208 { "CKM_SHA384_KEY_DERIVATION", CKM_SHA384_KEY_DERIVATION },
209 209 { "CKM_SHA512_KEY_DERIVATION", CKM_SHA512_KEY_DERIVATION },
210 210 { "CKM_SHA224_KEY_DERIVATION", CKM_SHA224_KEY_DERIVATION },
211 211 { "CKM_PBE_MD2_DES_CBC", CKM_PBE_MD2_DES_CBC },
212 212 { "CKM_PBE_MD5_DES_CBC", CKM_PBE_MD5_DES_CBC },
213 213 { "CKM_PBE_MD5_CAST_CBC", CKM_PBE_MD5_CAST_CBC },
214 214 { "CKM_PBE_MD5_CAST3_CBC", CKM_PBE_MD5_CAST3_CBC },
215 215 { "CKM_PBE_MD5_CAST5_CBC", CKM_PBE_MD5_CAST5_CBC },
216 216 { "CKM_PBE_MD5_CAST128_CBC", CKM_PBE_MD5_CAST128_CBC },
217 217 { "CKM_PBE_SHA1_CAST5_CBC", CKM_PBE_SHA1_CAST5_CBC },
218 218 { "CKM_PBE_SHA1_CAST128_CBC", CKM_PBE_SHA1_CAST128_CBC },
219 219 { "CKM_PBE_SHA1_RC4_128", CKM_PBE_SHA1_RC4_128 },
220 220 { "CKM_PBE_SHA1_RC4_40", CKM_PBE_SHA1_RC4_40 },
221 221 { "CKM_PBE_SHA1_DES3_EDE_CBC", CKM_PBE_SHA1_DES3_EDE_CBC },
222 222 { "CKM_PBE_SHA1_DES2_EDE_CBC", CKM_PBE_SHA1_DES2_EDE_CBC },
223 223 { "CKM_PBE_SHA1_RC2_128_CBC", CKM_PBE_SHA1_RC2_128_CBC },
224 224 { "CKM_PBE_SHA1_RC2_40_CBC", CKM_PBE_SHA1_RC2_40_CBC },
225 225 { "CKM_PKCS5_PBKD2", CKM_PKCS5_PBKD2 },
226 226 { "CKM_PBA_SHA1_WITH_SHA1_HMAC", CKM_PBA_SHA1_WITH_SHA1_HMAC },
227 227 { "CKM_KEY_WRAP_LYNKS", CKM_KEY_WRAP_LYNKS },
228 228 { "CKM_KEY_WRAP_SET_OAEP", CKM_KEY_WRAP_SET_OAEP },
229 229 { "CKM_KIP_DERIVE", CKM_KIP_DERIVE },
230 230 { "CKM_KIP_WRAP", CKM_KIP_WRAP },
231 231 { "CKM_KIP_MAC", CKM_KIP_MAC },
232 232 { "CKM_CAMELLIA_KEY_GEN", CKM_CAMELLIA_KEY_GEN },
233 233 { "CKM_CAMELLIA_ECB", CKM_CAMELLIA_ECB },
234 234 { "CKM_CAMELLIA_CBC", CKM_CAMELLIA_CBC },
235 235 { "CKM_CAMELLIA_MAC", CKM_CAMELLIA_MAC },
236 236 { "CKM_CAMELLIA_MAC_GENERAL", CKM_CAMELLIA_MAC_GENERAL },
237 237 { "CKM_CAMELLIA_CBC_PAD", CKM_CAMELLIA_CBC_PAD },
238 238 { "CKM_CAMELLIA_ECB_ENCRYPT_DATA", CKM_CAMELLIA_ECB_ENCRYPT_DATA },
239 239 { "CKM_CAMELLIA_CBC_ENCRYPT_DATA", CKM_CAMELLIA_CBC_ENCRYPT_DATA },
240 240 { "CKM_CAMELLIA_CTR", CKM_CAMELLIA_CTR },
241 241 { "CKM_ARIA_KEY_GEN", CKM_ARIA_KEY_GEN },
242 242 { "CKM_ARIA_ECB", CKM_ARIA_ECB },
243 243 { "CKM_ARIA_CBC", CKM_ARIA_CBC },
244 244 { "CKM_ARIA_MAC", CKM_ARIA_MAC },
245 245 { "CKM_ARIA_MAC_GENERAL", CKM_ARIA_MAC_GENERAL },
246 246 { "CKM_ARIA_CBC_PAD", CKM_ARIA_CBC_PAD },
247 247 { "CKM_ARIA_ECB_ENCRYPT_DATA", CKM_ARIA_ECB_ENCRYPT_DATA },
248 248 { "CKM_ARIA_CBC_ENCRYPT_DATA", CKM_ARIA_CBC_ENCRYPT_DATA },
249 249 { "CKM_SKIPJACK_KEY_GEN", CKM_SKIPJACK_KEY_GEN },
250 250 { "CKM_SKIPJACK_ECB64", CKM_SKIPJACK_ECB64 },
251 251 { "CKM_SKIPJACK_CBC64", CKM_SKIPJACK_CBC64 },
252 252 { "CKM_SKIPJACK_OFB64", CKM_SKIPJACK_OFB64 },
253 253 { "CKM_SKIPJACK_CFB64", CKM_SKIPJACK_CFB64 },
254 254 { "CKM_SKIPJACK_CFB32", CKM_SKIPJACK_CFB32 },
255 255 { "CKM_SKIPJACK_CFB16", CKM_SKIPJACK_CFB16 },
256 256 { "CKM_SKIPJACK_CFB8", CKM_SKIPJACK_CFB8 },
257 257 { "CKM_SKIPJACK_WRAP", CKM_SKIPJACK_WRAP },
258 258 { "CKM_SKIPJACK_PRIVATE_WRAP", CKM_SKIPJACK_PRIVATE_WRAP },
259 259 { "CKM_SKIPJACK_RELAYX", CKM_SKIPJACK_RELAYX },
260 260 { "CKM_KEA_KEY_PAIR_GEN", CKM_KEA_KEY_PAIR_GEN },
261 261 { "CKM_KEA_KEY_DERIVE", CKM_KEA_KEY_DERIVE },
262 262 { "CKM_FORTEZZA_TIMESTAMP", CKM_FORTEZZA_TIMESTAMP },
263 263 { "CKM_BATON_KEY_GEN", CKM_BATON_KEY_GEN },
264 264 { "CKM_BATON_ECB128", CKM_BATON_ECB128 },
265 265 { "CKM_BATON_ECB96", CKM_BATON_ECB96 },
266 266 { "CKM_BATON_CBC128", CKM_BATON_CBC128 },
267 267 { "CKM_BATON_COUNTER", CKM_BATON_COUNTER },
268 268 { "CKM_BATON_SHUFFLE", CKM_BATON_SHUFFLE },
269 269 { "CKM_BATON_WRAP", CKM_BATON_WRAP },
270 270 { "CKM_EC_KEY_PAIR_GEN", CKM_EC_KEY_PAIR_GEN },
271 271 { "CKM_ECDSA", CKM_ECDSA },
272 272 { "CKM_ECDSA_SHA1", CKM_ECDSA_SHA1 },
273 273 { "CKM_ECDH1_DERIVE", CKM_ECDH1_DERIVE },
274 274 { "CKM_ECDH1_COFACTOR_DERIVE", CKM_ECDH1_COFACTOR_DERIVE },
275 275 { "CKM_ECMQV_DERIVE", CKM_ECMQV_DERIVE },
276 276 { "CKM_JUNIPER_KEY_GEN", CKM_JUNIPER_KEY_GEN },
277 277 { "CKM_JUNIPER_ECB128", CKM_JUNIPER_ECB128 },
278 278 { "CKM_JUNIPER_CBC128", CKM_JUNIPER_CBC128 },
279 279 { "CKM_JUNIPER_COUNTER", CKM_JUNIPER_COUNTER },
280 280 { "CKM_JUNIPER_SHUFFLE", CKM_JUNIPER_SHUFFLE },
281 281 { "CKM_JUNIPER_WRAP", CKM_JUNIPER_WRAP },
282 282 { "CKM_FASTHASH", CKM_FASTHASH },
283 283 { "CKM_AES_KEY_GEN", CKM_AES_KEY_GEN },
284 284 { "CKM_AES_ECB", CKM_AES_ECB },
285 285 { "CKM_AES_CBC", CKM_AES_CBC },
286 286 { "CKM_AES_MAC", CKM_AES_MAC },
287 287 { "CKM_AES_MAC_GENERAL", CKM_AES_MAC_GENERAL },
288 288 { "CKM_AES_CBC_PAD", CKM_AES_CBC_PAD },
289 289 { "CKM_AES_CTR", CKM_AES_CTR },
290 290 { "CKM_BLOWFISH_KEY_GEN", CKM_BLOWFISH_KEY_GEN },
291 291 { "CKM_BLOWFISH_CBC", CKM_BLOWFISH_CBC },
292 292 { "CKM_TWOFISH_KEY_GEN", CKM_TWOFISH_KEY_GEN },
293 293 { "CKM_TWOFISH_CBC", CKM_TWOFISH_CBC },
|
↓ open down ↓ |
257 lines elided |
↑ open up ↑ |
294 294 { "CKM_DES_ECB_ENCRYPT_DATA", CKM_DES_ECB_ENCRYPT_DATA },
295 295 { "CKM_DES_CBC_ENCRYPT_DATA", CKM_DES_CBC_ENCRYPT_DATA },
296 296 { "CKM_DES3_ECB_ENCRYPT_DATA", CKM_DES3_ECB_ENCRYPT_DATA },
297 297 { "CKM_DES3_CBC_ENCRYPT_DATA", CKM_DES3_CBC_ENCRYPT_DATA },
298 298 { "CKM_AES_ECB_ENCRYPT_DATA", CKM_AES_ECB_ENCRYPT_DATA },
299 299 { "CKM_AES_CBC_ENCRYPT_DATA", CKM_AES_CBC_ENCRYPT_DATA },
300 300 { "CKM_DSA_PARAMETER_GEN", CKM_DSA_PARAMETER_GEN },
301 301 { "CKM_DH_PKCS_PARAMETER_GEN", CKM_DH_PKCS_PARAMETER_GEN },
302 302 { "CKM_X9_42_DH_PARAMETER_GEN", CKM_X9_42_DH_PARAMETER_GEN },
303 303 /*
304 - * Values above 0x8000000 (CKM_VENDOR_DEFINED) are represented
304 + * Values >= 0x8000000 (CKM_VENDOR_DEFINED) are represented
305 305 * as strings with hexadecimal numbers (e.g., "0x8123456").
306 306 */
307 307 { NULL, 0 }
308 308 };
309 309
310 310
311 311 /*
312 312 * pkcs11_mech_comp - compare two pkcs11_mapping_t structures
313 313 *
314 314 * Return a strcmp-like result (positive, zero, or negative).
315 315 * For use with bsearch(3C) in pkcs11_mech2str().
316 316 */
317 317 static int
318 318 pkcs11_mech_comp(const void *mapping1, const void *mapping2) {
319 319 return (((pkcs11_mapping_t *)mapping1)->mech -
320 320 ((pkcs11_mapping_t *)mapping2)->mech);
321 321 }
322 322
323 323
324 324 /*
325 325 * pkcs11_mech2str - convert PKCS#11 mech to a string
326 326 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
327 327 * Anything below CKM_VENDOR_DEFINED that wasn't in the mapping table
328 328 * at build time causes NULL to be returned. Anything above it also
329 329 * returns NULL since we have no way to know its real name.
330 330 */
331 331 const char
332 332 *pkcs11_mech2str(CK_MECHANISM_TYPE mech)
333 333 {
334 334 pkcs11_mapping_t target;
335 335 pkcs11_mapping_t *result = NULL;
336 336
337 - if (mech > CKM_VENDOR_DEFINED) {
337 + if (mech >= CKM_VENDOR_DEFINED) {
338 338 return (NULL);
339 339 }
340 340
341 341 /* Search for the mechanism number using bsearch(3C) */
342 342 target.mech = mech;
343 343 target.str = NULL;
344 344 result = (pkcs11_mapping_t *)bsearch((void *)&target, (void *)mapping,
345 345 (sizeof (mapping) / sizeof (pkcs11_mapping_t)) - 1,
346 346 sizeof (pkcs11_mapping_t), pkcs11_mech_comp);
347 347 if (result != NULL) {
348 348 return (result->str);
349 349 }
350 350
351 351 return (NULL);
352 352 }
353 353
354 354 /*
355 355 * pkcs11_str2mech - convert a string into a PKCS#11 mech number.
356 356 *
357 357 * Since there isn't a reserved value for an invalid mech we return
358 358 * CKR_MECHANISM_INVALID for anything we don't recognise.
359 359 * The value in mech isn't meaningful in these cases.
360 360 */
361 361 CK_RV
362 362 pkcs11_str2mech(char *mech_str, CK_MECHANISM_TYPE_PTR mech)
363 363 {
364 364 int i;
365 365 int compare_off = 0;
366 366
367 367 if (mech_str == NULL)
368 368 return (CKR_MECHANISM_INVALID);
369 369
370 370 if (strncasecmp(mech_str, "0x", 2) == 0) {
371 371 long long llnum;
372 372 cryptodebug("pkcs11_str2mech: hex string passed in: %s",
373 373 mech_str);
374 374 llnum = strtoll(mech_str, NULL, 16);
375 375 if ((llnum >= CKM_VENDOR_DEFINED) && (llnum <= UINT_MAX)) {
376 376 *mech = llnum;
377 377 return (CKR_OK);
378 378 } else {
379 379 return (CKR_MECHANISM_INVALID);
380 380 }
381 381 }
382 382
383 383 /* If there's no CKM_ prefix, then ignore it in comparisons */
384 384 if (strncasecmp(mech_str, "CKM_", 4) != 0) {
385 385 cryptodebug("pkcs11_str2mech: no CKM_ prefix: %s", mech_str);
386 386 cryptodebug("pkcs11_str2mech: with prefix: CKM_%s", mech_str);
387 387 compare_off = 4;
388 388 }
389 389
390 390 /* Linear search for a matching string */
391 391 for (i = 0; mapping[i].str; i++) {
392 392 if (strcasecmp(&mapping[i].str[compare_off], mech_str) == 0) {
393 393 *mech = mapping[i].mech;
394 394 return (CKR_OK);
395 395 }
396 396 }
397 397
398 398 return (CKR_MECHANISM_INVALID);
399 399 }
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX