History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/security/pkcs11/P11KeyPairGenerator.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/security/pkcs11/P11KeyPairGenerator.java+329−0
@@ -0,0 +1,329 @@
1/*
2 * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package sun.security.pkcs11;
27
28import java.math.BigInteger;
29
30import java.security.*;
31import java.security.spec.*;
32
33import javax.crypto.spec.DHParameterSpec;
34
35import sun.security.provider.ParameterCache;
36
37import static sun.security.pkcs11.TemplateManager.*;
38import sun.security.pkcs11.wrapper.*;
39import static sun.security.pkcs11.wrapper.PKCS11Constants.*;
40
41import sun.security.rsa.RSAKeyFactory;
42
43/**
44 * KeyPairGenerator implementation class. This class currently supports
45 * RSA, DSA, DH, and EC.
46 *
47 * Note that for DSA and DH we rely on the Sun and SunJCE providers to
48 * obtain the parameters from.
49 *
50 * @author Andreas Sterbenz
51 * @since 1.5
52 */
53final class P11KeyPairGenerator extends KeyPairGeneratorSpi {
54
55 // token instance
56 private final Token token;
57
58 // algorithm name
59 private final String algorithm;
60
61 // mechanism id
62 private final long mechanism;
63
64 // selected or default key size, always valid
65 private int keySize;
66
67 // parameters specified via init, if any
68 private AlgorithmParameterSpec params;
69
70 // for RSA, selected or default value of public exponent, always valid
71 private BigInteger rsaPublicExponent = RSAKeyGenParameterSpec.F4;
72
73 // SecureRandom instance, if specified in init
74 private SecureRandom random;
75
76 P11KeyPairGenerator(Token token, String algorithm, long mechanism)
77 throws PKCS11Exception {
78 super();
79 this.token = token;
80 this.algorithm = algorithm;
81 this.mechanism = mechanism;
82 if (algorithm.equals("EC")) {
83 initialize(256, null);
84 } else {
85 initialize(1024, null);
86 }
87 }
88
89 // see JCA spec
90 public void initialize(int keySize, SecureRandom random) {
91 token.ensureValid();
92 try {
93 checkKeySize(keySize, null);
94 } catch (InvalidAlgorithmParameterException e) {
95 throw new InvalidParameterException(e.getMessage());
96 }
97 this.keySize = keySize;
98 this.params = null;
99 this.random = random;
100 if (algorithm.equals("EC")) {
101 params = P11ECKeyFactory.getECParameterSpec(keySize);
102 if (params == null) {
103 throw new InvalidParameterException(
104 "No EC parameters available for key size "
105 + keySize + " bits");
106 }
107 }
108 }
109
110 // see JCA spec
111 public void initialize(AlgorithmParameterSpec params, SecureRandom random)
112 throws InvalidAlgorithmParameterException {
113 token.ensureValid();
114 if (algorithm.equals("DH")) {
115 if (params instanceof DHParameterSpec == false) {
116 throw new InvalidAlgorithmParameterException
117 ("DHParameterSpec required for Diffie-Hellman");
118 }
119 DHParameterSpec dhParams = (DHParameterSpec)params;
120 int tmpKeySize = dhParams.getP().bitLength();
121 checkKeySize(tmpKeySize, dhParams);
122 this.keySize = tmpKeySize;
123 this.params = dhParams;
124 // XXX sanity check params
125 } else if (algorithm.equals("RSA")) {
126 if (params instanceof RSAKeyGenParameterSpec == false) {
127 throw new InvalidAlgorithmParameterException
128 ("RSAKeyGenParameterSpec required for RSA");
129 }
130 RSAKeyGenParameterSpec rsaParams = (RSAKeyGenParameterSpec)params;
131 int tmpKeySize = rsaParams.getKeysize();
132 checkKeySize(tmpKeySize, rsaParams);
133 this.keySize = tmpKeySize;
134 this.params = null;
135 this.rsaPublicExponent = rsaParams.getPublicExponent();
136 // XXX sanity check params
137 } else if (algorithm.equals("DSA")) {
138 if (params instanceof DSAParameterSpec == false) {
139 throw new InvalidAlgorithmParameterException
140 ("DSAParameterSpec required for DSA");
141 }
142 DSAParameterSpec dsaParams = (DSAParameterSpec)params;
143 int tmpKeySize = dsaParams.getP().bitLength();
144 checkKeySize(tmpKeySize, dsaParams);
145 this.keySize = tmpKeySize;
146 this.params = dsaParams;
147 // XXX sanity check params
148 } else if (algorithm.equals("EC")) {
149 ECParameterSpec ecParams;
150 if (params instanceof ECParameterSpec) {
151 ecParams = P11ECKeyFactory.getECParameterSpec(
152 (ECParameterSpec)params);
153 if (ecParams == null) {
154 throw new InvalidAlgorithmParameterException
155 ("Unsupported curve: " + params);
156 }
157 } else if (params instanceof ECGenParameterSpec) {
158 String name = ((ECGenParameterSpec)params).getName();
159 ecParams = P11ECKeyFactory.getECParameterSpec(name);
160 if (ecParams == null) {
161 throw new InvalidAlgorithmParameterException
162 ("Unknown curve name: " + name);
163 }
164 } else {
165 throw new InvalidAlgorithmParameterException
166 ("ECParameterSpec or ECGenParameterSpec required for EC");
167 }
168 int tmpKeySize = ecParams.getCurve().getField().getFieldSize();
169 checkKeySize(tmpKeySize, ecParams);
170 this.keySize = tmpKeySize;
171 this.params = ecParams;
172 } else {
173 throw new ProviderException("Unknown algorithm: " + algorithm);
174 }
175 this.random = random;
176 }
177
178 private void checkKeySize(int keySize, AlgorithmParameterSpec params)
179 throws InvalidAlgorithmParameterException {
180 if (algorithm.equals("EC")) {
181 if (keySize < 112) {
182 throw new InvalidAlgorithmParameterException
183 ("Key size must be at least 112 bit");
184 }
185 if (keySize > 2048) {
186 // sanity check, nobody really wants keys this large
187 throw new InvalidAlgorithmParameterException
188 ("Key size must be at most 2048 bit");
189 }
190 return;
191 } else if (algorithm.equals("RSA")) {
192 BigInteger tmpExponent = rsaPublicExponent;
193 if (params != null) {
194 // Already tested for instanceof RSAKeyGenParameterSpec above
195 tmpExponent =
196 ((RSAKeyGenParameterSpec)params).getPublicExponent();
197 }
198 try {
199 // This provider supports 64K or less.
200 RSAKeyFactory.checkKeyLengths(keySize, tmpExponent,
201 512, 64 * 1024);
202 } catch (InvalidKeyException e) {
203 throw new InvalidAlgorithmParameterException(e.getMessage());
204 }
205 return;
206 }
207
208 if (keySize < 512) {
209 throw new InvalidAlgorithmParameterException
210 ("Key size must be at least 512 bit");
211 }
212 if (algorithm.equals("DH") && (params != null)) {
213 // sanity check, nobody really wants keys this large
214 if (keySize > 64 * 1024) {
215 throw new InvalidAlgorithmParameterException
216 ("Key size must be at most 65536 bit");
217 }
218 } else {
219 // this restriction is in the spec for DSA
220 // since we currently use DSA parameters for DH as well,
221 // it also applies to DH if no parameters are specified
222 if ((keySize > 1024) || ((keySize & 0x3f) != 0)) {
223 throw new InvalidAlgorithmParameterException
224 ("Key size must be a multiple of 64 and at most 1024 bit");
225 }
226 }
227 }
228
229 // see JCA spec
230 public KeyPair generateKeyPair() {
231 token.ensureValid();
232 CK_ATTRIBUTE[] publicKeyTemplate;
233 CK_ATTRIBUTE[] privateKeyTemplate;
234 long keyType;
235 if (algorithm.equals("RSA")) {
236 keyType = CKK_RSA;
237 publicKeyTemplate = new CK_ATTRIBUTE[] {
238 new CK_ATTRIBUTE(CKA_MODULUS_BITS, keySize),
239 new CK_ATTRIBUTE(CKA_PUBLIC_EXPONENT, rsaPublicExponent),
240 };
241 privateKeyTemplate = new CK_ATTRIBUTE[] {
242 // empty
243 };
244 } else if (algorithm.equals("DSA")) {
245 keyType = CKK_DSA;
246 DSAParameterSpec dsaParams;
247 if (params == null) {
248 try {
249 dsaParams = ParameterCache.getDSAParameterSpec
250 (keySize, random);
251 } catch (GeneralSecurityException e) {
252 throw new ProviderException
253 ("Could not generate DSA parameters", e);
254 }
255 } else {
256 dsaParams = (DSAParameterSpec)params;
257 }
258 publicKeyTemplate = new CK_ATTRIBUTE[] {
259 new CK_ATTRIBUTE(CKA_PRIME, dsaParams.getP()),
260 new CK_ATTRIBUTE(CKA_SUBPRIME, dsaParams.getQ()),
261 new CK_ATTRIBUTE(CKA_BASE, dsaParams.getG()),
262 };
263 privateKeyTemplate = new CK_ATTRIBUTE[] {
264 // empty
265 };
266 } else if (algorithm.equals("DH")) {
267 keyType = CKK_DH;
268 DHParameterSpec dhParams;
269 int privateBits;
270 if (params == null) {
271 try {
272 dhParams = ParameterCache.getDHParameterSpec
273 (keySize, random);
274 } catch (GeneralSecurityException e) {
275 throw new ProviderException
276 ("Could not generate DH parameters", e);
277 }
278 privateBits = 0;
279 } else {
280 dhParams = (DHParameterSpec)params;
281 privateBits = dhParams.getL();
282 }
283 if (privateBits <= 0) {
284 // XXX find better defaults
285 privateBits = (keySize >= 1024) ? 768 : 512;
286 }
287 publicKeyTemplate = new CK_ATTRIBUTE[] {
288 new CK_ATTRIBUTE(CKA_PRIME, dhParams.getP()),
289 new CK_ATTRIBUTE(CKA_BASE, dhParams.getG())
290 };
291 privateKeyTemplate = new CK_ATTRIBUTE[] {
292 new CK_ATTRIBUTE(CKA_VALUE_BITS, privateBits),
293 };
294 } else if (algorithm.equals("EC")) {
295 keyType = CKK_EC;
296 byte[] encodedParams =
297 P11ECKeyFactory.encodeParameters((ECParameterSpec)params);
298 publicKeyTemplate = new CK_ATTRIBUTE[] {
299 new CK_ATTRIBUTE(CKA_EC_PARAMS, encodedParams),
300 };
301 privateKeyTemplate = new CK_ATTRIBUTE[] {
302 // empty
303 };
304 } else {
305 throw new ProviderException("Unknown algorithm: " + algorithm);
306 }
307 Session session = null;
308 try {
309 session = token.getObjSession();
310 publicKeyTemplate = token.getAttributes
311 (O_GENERATE, CKO_PUBLIC_KEY, keyType, publicKeyTemplate);
312 privateKeyTemplate = token.getAttributes
313 (O_GENERATE, CKO_PRIVATE_KEY, keyType, privateKeyTemplate);
314 long[] keyIDs = token.p11.C_GenerateKeyPair
315 (session.id(), new CK_MECHANISM(mechanism),
316 publicKeyTemplate, privateKeyTemplate);
317 PublicKey publicKey = P11Key.publicKey
318 (session, keyIDs[0], algorithm, keySize, publicKeyTemplate);
319 PrivateKey privateKey = P11Key.privateKey
320 (session, keyIDs[1], algorithm, keySize, privateKeyTemplate);
321 return new KeyPair(publicKey, privateKey);
322 } catch (PKCS11Exception e) {
323 throw new ProviderException(e);
324 } finally {
325 token.releaseSession(session);
326 }
327 }
328
329}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t