Skip to content

Commit c9d6e01

Browse files
author
Anthony Scarpino
committed
8358076: KeyFactory.getInstance("EdDSA").generatePublic(null) throws NPE
Reviewed-by: weijun
1 parent 94039e2 commit c9d6e01

File tree

4 files changed

+180
-149
lines changed

4 files changed

+180
-149
lines changed

‎src/java.base/share/classes/sun/security/ec/ECKeyFactory.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -219,6 +219,8 @@ private PublicKey implGeneratePublic(KeySpec keySpec)
219219
}
220220
yield new ECPublicKeyImpl(p8key.getPubKeyEncoded());
221221
}
222+
case null -> throw new InvalidKeySpecException(
223+
"keySpec must not be null");
222224
default ->
223225
throw new InvalidKeySpecException(keySpec.getClass().getName() +
224226
" not supported.");
@@ -239,6 +241,8 @@ private PrivateKey implGeneratePrivate(KeySpec keySpec)
239241
}
240242
case ECPrivateKeySpec e ->
241243
new ECPrivateKeyImpl(e.getS(), e.getParams());
244+
case null -> throw new InvalidKeySpecException(
245+
"keySpec must not be null");
242246
default ->
243247
throw new InvalidKeySpecException(keySpec.getClass().getName() +
244248
" not supported.");

‎src/java.base/share/classes/sun/security/ec/XDHKeyFactory.java‎

Lines changed: 57 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -144,64 +144,72 @@ protected PrivateKey engineGeneratePrivate(KeySpec keySpec)
144144
private PublicKey generatePublicImpl(KeySpec keySpec)
145145
throws InvalidKeyException, InvalidKeySpecException {
146146

147-
if (keySpec instanceof X509EncodedKeySpec) {
148-
X509EncodedKeySpec x509Spec = (X509EncodedKeySpec) keySpec;
149-
XDHPublicKeyImpl result =
150-
new XDHPublicKeyImpl(x509Spec.getEncoded());
151-
checkLockedParams(InvalidKeySpecException::new,
152-
result.getParams());
153-
return result;
154-
} else if (keySpec instanceof XECPublicKeySpec) {
155-
XECPublicKeySpec publicKeySpec = (XECPublicKeySpec) keySpec;
156-
XECParameters params = XECParameters.get(
157-
InvalidKeySpecException::new, publicKeySpec.getParams());
158-
checkLockedParams(InvalidKeySpecException::new, params);
159-
return new XDHPublicKeyImpl(params, publicKeySpec.getU());
160-
} else if (keySpec instanceof PKCS8EncodedKeySpec p8) {
161-
PKCS8Key p8key = new XDHPrivateKeyImpl(p8.getEncoded());
162-
if (!p8key.hasPublicKey()) {
163-
throw new InvalidKeySpecException("No public key found.");
147+
return switch (keySpec) {
148+
case X509EncodedKeySpec x509Spec -> {
149+
XDHPublicKeyImpl result =
150+
new XDHPublicKeyImpl(x509Spec.getEncoded());
151+
checkLockedParams(InvalidKeySpecException::new,
152+
result.getParams());
153+
yield result;
164154
}
165-
XDHPublicKeyImpl result =
166-
new XDHPublicKeyImpl(p8key.getPubKeyEncoded());
167-
checkLockedParams(InvalidKeySpecException::new,
168-
result.getParams());
169-
return result;
170-
} else {
171-
throw new InvalidKeySpecException(keySpec.getClass().getName() +
172-
" not supported.");
173-
}
155+
case XECPublicKeySpec publicKeySpec -> {
156+
XECParameters params = XECParameters.get(
157+
InvalidKeySpecException::new, publicKeySpec.getParams());
158+
checkLockedParams(InvalidKeySpecException::new, params);
159+
yield new XDHPublicKeyImpl(params, publicKeySpec.getU());
160+
}
161+
case PKCS8EncodedKeySpec p8 -> {
162+
PKCS8Key p8key = new XDHPrivateKeyImpl(p8.getEncoded());
163+
if (!p8key.hasPublicKey()) {
164+
throw new InvalidKeySpecException("No public key found.");
165+
}
166+
XDHPublicKeyImpl result =
167+
new XDHPublicKeyImpl(p8key.getPubKeyEncoded());
168+
checkLockedParams(InvalidKeySpecException::new,
169+
result.getParams());
170+
yield result;
171+
}
172+
case null -> throw new InvalidKeySpecException(
173+
"keySpec must not be null");
174+
default ->
175+
throw new InvalidKeySpecException(keySpec.getClass().getName() +
176+
" not supported.");
177+
};
174178
}
175179

176180
private PrivateKey generatePrivateImpl(KeySpec keySpec)
177181
throws InvalidKeyException, InvalidKeySpecException {
178182

179-
if (keySpec instanceof PKCS8EncodedKeySpec) {
180-
PKCS8EncodedKeySpec pkcsSpec = (PKCS8EncodedKeySpec) keySpec;
181-
byte[] encoded = pkcsSpec.getEncoded();
182-
try {
183-
XDHPrivateKeyImpl result = new XDHPrivateKeyImpl(encoded);
184-
checkLockedParams(InvalidKeySpecException::new,
183+
return switch (keySpec) {
184+
case PKCS8EncodedKeySpec pkcsSpec -> {
185+
byte[] encoded = pkcsSpec.getEncoded();
186+
try {
187+
XDHPrivateKeyImpl result = new XDHPrivateKeyImpl(encoded);
188+
checkLockedParams(InvalidKeySpecException::new,
185189
result.getParams());
186-
return result;
187-
} finally {
188-
Arrays.fill(encoded, (byte) 0);
190+
yield result;
191+
} finally {
192+
Arrays.fill(encoded, (byte) 0);
193+
}
189194
}
190-
} else if (keySpec instanceof XECPrivateKeySpec) {
191-
XECPrivateKeySpec privateKeySpec = (XECPrivateKeySpec) keySpec;
192-
XECParameters params = XECParameters.get(
193-
InvalidKeySpecException::new, privateKeySpec.getParams());
194-
checkLockedParams(InvalidKeySpecException::new, params);
195-
byte[] scalar = privateKeySpec.getScalar();
196-
try {
197-
return new XDHPrivateKeyImpl(params, scalar);
198-
} finally {
199-
Arrays.fill(scalar, (byte)0);
195+
case XECPrivateKeySpec privateKeySpec -> {
196+
XECParameters params = XECParameters.get(
197+
InvalidKeySpecException::new, privateKeySpec.getParams());
198+
checkLockedParams(InvalidKeySpecException::new, params);
199+
200+
byte[] scalar = privateKeySpec.getScalar();
201+
try {
202+
yield new XDHPrivateKeyImpl(params, scalar);
203+
} finally {
204+
Arrays.fill(scalar, (byte) 0);
205+
}
200206
}
201-
} else {
202-
throw new InvalidKeySpecException(
203-
"Only PKCS8EncodedKeySpec and XECPrivateKeySpec supported");
204-
}
207+
case null -> throw new InvalidKeySpecException(
208+
"keySpec must not be null");
209+
default ->
210+
throw new InvalidKeySpecException(keySpec.getClass().getName() +
211+
" not supported.");
212+
};
205213
}
206214

207215
protected <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec)

‎src/java.base/share/classes/sun/security/ec/ed/EdDSAKeyFactory.java‎

Lines changed: 52 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -137,61 +137,68 @@ protected PrivateKey engineGeneratePrivate(KeySpec keySpec)
137137
private PublicKey generatePublicImpl(KeySpec keySpec)
138138
throws InvalidKeyException, InvalidKeySpecException {
139139

140-
if (keySpec instanceof X509EncodedKeySpec) {
141-
X509EncodedKeySpec x509Spec = (X509EncodedKeySpec) keySpec;
142-
EdDSAPublicKeyImpl result =
143-
new EdDSAPublicKeyImpl(x509Spec.getEncoded());
144-
checkLockedParams(InvalidKeySpecException::new,
145-
result.getParams());
146-
return result;
147-
} else if (keySpec instanceof EdECPublicKeySpec) {
148-
EdECPublicKeySpec publicKeySpec = (EdECPublicKeySpec) keySpec;
149-
EdDSAParameters params = EdDSAParameters.get(
150-
InvalidKeySpecException::new, publicKeySpec.getParams());
151-
checkLockedParams(InvalidKeySpecException::new, params);
152-
return new EdDSAPublicKeyImpl(params, publicKeySpec.getPoint());
153-
} else if (keySpec instanceof PKCS8EncodedKeySpec p8) {
154-
PKCS8Key p8key = new EdDSAPrivateKeyImpl(p8.getEncoded());
155-
if (!p8key.hasPublicKey()) {
156-
throw new InvalidKeySpecException("No public key found.");
140+
return switch (keySpec) {
141+
case X509EncodedKeySpec x509Spec -> {
142+
EdDSAPublicKeyImpl result =
143+
new EdDSAPublicKeyImpl(x509Spec.getEncoded());
144+
checkLockedParams(InvalidKeySpecException::new,
145+
result.getParams());
146+
yield result;
157147
}
158-
return new EdDSAPublicKeyImpl(p8key.getPubKeyEncoded());
159-
} else {
160-
throw new InvalidKeySpecException(keySpec.getClass().getName() +
161-
" not supported.");
162-
}
148+
case EdECPublicKeySpec publicKeySpec -> {
149+
EdDSAParameters params = EdDSAParameters.get(
150+
InvalidKeySpecException::new, publicKeySpec.getParams());
151+
checkLockedParams(InvalidKeySpecException::new, params);
152+
yield new EdDSAPublicKeyImpl(params, publicKeySpec.getPoint());
153+
}
154+
case PKCS8EncodedKeySpec p8 -> {
155+
PKCS8Key p8key = new EdDSAPrivateKeyImpl(p8.getEncoded());
156+
if (!p8key.hasPublicKey()) {
157+
throw new InvalidKeySpecException("No public key found.");
158+
}
159+
yield new EdDSAPublicKeyImpl(p8key.getPubKeyEncoded());
160+
}
161+
case null -> throw new InvalidKeySpecException(
162+
"keySpec must not be null");
163+
default ->
164+
throw new InvalidKeySpecException(keySpec.getClass().getName() +
165+
" not supported.");
166+
};
163167
}
164168

165169
private PrivateKey generatePrivateImpl(KeySpec keySpec)
166170
throws InvalidKeyException, InvalidKeySpecException {
167171

168-
if (keySpec instanceof PKCS8EncodedKeySpec) {
169-
PKCS8EncodedKeySpec pkcsSpec = (PKCS8EncodedKeySpec) keySpec;
170-
byte[] encoded = pkcsSpec.getEncoded();
171-
try {
172-
EdDSAPrivateKeyImpl result =
172+
return switch (keySpec) {
173+
case PKCS8EncodedKeySpec pkcsSpec -> {
174+
byte[] encoded = pkcsSpec.getEncoded();
175+
try {
176+
EdDSAPrivateKeyImpl result =
173177
new EdDSAPrivateKeyImpl(encoded);
174-
checkLockedParams(InvalidKeySpecException::new,
178+
checkLockedParams(InvalidKeySpecException::new,
175179
result.getParams());
176-
return result;
177-
} finally {
178-
Arrays.fill(encoded, (byte) 0);
180+
yield result;
181+
} finally {
182+
Arrays.fill(encoded, (byte) 0);
183+
}
179184
}
180-
} else if (keySpec instanceof EdECPrivateKeySpec) {
181-
EdECPrivateKeySpec privateKeySpec = (EdECPrivateKeySpec) keySpec;
182-
EdDSAParameters params = EdDSAParameters.get(
183-
InvalidKeySpecException::new, privateKeySpec.getParams());
184-
checkLockedParams(InvalidKeySpecException::new, params);
185-
byte[] bytes = privateKeySpec.getBytes();
186-
try {
187-
return new EdDSAPrivateKeyImpl(params, bytes);
188-
} finally {
189-
Arrays.fill(bytes, (byte)0);
185+
case EdECPrivateKeySpec privateKeySpec -> {
186+
EdDSAParameters params = EdDSAParameters.get(
187+
InvalidKeySpecException::new, privateKeySpec.getParams());
188+
checkLockedParams(InvalidKeySpecException::new, params);
189+
byte[] bytes = privateKeySpec.getBytes();
190+
try {
191+
yield new EdDSAPrivateKeyImpl(params, bytes);
192+
} finally {
193+
Arrays.fill(bytes, (byte) 0);
194+
}
190195
}
191-
} else {
192-
throw new InvalidKeySpecException(
193-
"Only PKCS8EncodedKeySpec and EdECPrivateKeySpec supported");
194-
}
196+
case null -> throw new InvalidKeySpecException(
197+
"keySpec must not be null");
198+
default ->
199+
throw new InvalidKeySpecException(keySpec.getClass().getName() +
200+
" not supported.");
201+
};
195202
}
196203

197204
protected <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec)

‎src/java.base/share/classes/sun/security/rsa/RSAKeyFactory.java‎

Lines changed: 67 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -320,71 +320,83 @@ private PrivateKey translatePrivateKey(PrivateKey key)
320320
// internal implementation of generatePublic. See JCA doc
321321
private PublicKey generatePublic(KeySpec keySpec)
322322
throws GeneralSecurityException {
323-
if (keySpec instanceof X509EncodedKeySpec) {
324-
return RSAPublicKeyImpl.newKey(type, "X.509",
325-
((X509EncodedKeySpec)keySpec).getEncoded());
326-
} else if (keySpec instanceof RSAPublicKeySpec rsaSpec) {
327-
try {
328-
return new RSAPublicKeyImpl(
329-
type, rsaSpec.getParams(),
330-
rsaSpec.getModulus(),
331-
rsaSpec.getPublicExponent()
332-
);
333-
} catch (ProviderException e) {
334-
throw new InvalidKeySpecException(e);
323+
return switch (keySpec) {
324+
case X509EncodedKeySpec x509 ->
325+
RSAPublicKeyImpl.newKey(type, "X.509", x509.getEncoded());
326+
327+
case RSAPublicKeySpec rsaSpec -> {
328+
try {
329+
yield new RSAPublicKeyImpl(
330+
type, rsaSpec.getParams(),
331+
rsaSpec.getModulus(),
332+
rsaSpec.getPublicExponent()
333+
);
334+
} catch (ProviderException e) {
335+
throw new InvalidKeySpecException(e);
336+
}
335337
}
336-
} else if (keySpec instanceof PKCS8EncodedKeySpec p8) {
337-
PKCS8Key p8key = new PKCS8Key(p8.getEncoded());
338-
if (!p8key.hasPublicKey()) {
339-
throw new InvalidKeySpecException("No public key found.");
338+
case PKCS8EncodedKeySpec p8 -> {
339+
PKCS8Key p8key = new PKCS8Key(p8.getEncoded());
340+
if (!p8key.hasPublicKey()) {
341+
throw new InvalidKeySpecException("No public key found.");
342+
}
343+
yield RSAPublicKeyImpl.newKey(type, "X.509",
344+
p8key.getPubKeyEncoded());
340345
}
341-
return RSAPublicKeyImpl.newKey(type, "X.509",
342-
p8key.getPubKeyEncoded());
343-
} else {
344-
throw new InvalidKeySpecException(keySpec.getClass().getName() + " not supported.");
345-
}
346+
case null -> throw new InvalidKeySpecException(
347+
"keySpec must not be null");
348+
default ->
349+
throw new InvalidKeySpecException(keySpec.getClass().getName() +
350+
" not supported.");
351+
};
346352
}
347353

348354
// internal implementation of generatePrivate. See JCA doc
349355
private PrivateKey generatePrivate(KeySpec keySpec)
350356
throws GeneralSecurityException {
351-
if (keySpec instanceof PKCS8EncodedKeySpec) {
352-
byte[] encoded = ((PKCS8EncodedKeySpec)keySpec).getEncoded();
353-
try {
354-
return RSAPrivateCrtKeyImpl.newKey(type, "PKCS#8", encoded);
355-
} finally {
356-
Arrays.fill(encoded, (byte)0);
357+
return switch (keySpec) {
358+
case PKCS8EncodedKeySpec p8 -> {
359+
byte[] encoded = p8.getEncoded();
360+
try {
361+
yield RSAPrivateCrtKeyImpl.newKey(type, "PKCS#8", encoded);
362+
} finally {
363+
Arrays.fill(encoded, (byte) 0);
364+
}
357365
}
358-
} else if (keySpec instanceof RSAPrivateCrtKeySpec rsaSpec) {
359-
try {
360-
return new RSAPrivateCrtKeyImpl(
361-
type, rsaSpec.getParams(),
362-
rsaSpec.getModulus(),
363-
rsaSpec.getPublicExponent(),
364-
rsaSpec.getPrivateExponent(),
365-
rsaSpec.getPrimeP(),
366-
rsaSpec.getPrimeQ(),
367-
rsaSpec.getPrimeExponentP(),
368-
rsaSpec.getPrimeExponentQ(),
369-
rsaSpec.getCrtCoefficient()
370-
);
371-
} catch (ProviderException e) {
372-
throw new InvalidKeySpecException(e);
366+
case RSAPrivateCrtKeySpec rsaSpec -> {
367+
try {
368+
yield new RSAPrivateCrtKeyImpl(
369+
type, rsaSpec.getParams(),
370+
rsaSpec.getModulus(),
371+
rsaSpec.getPublicExponent(),
372+
rsaSpec.getPrivateExponent(),
373+
rsaSpec.getPrimeP(),
374+
rsaSpec.getPrimeQ(),
375+
rsaSpec.getPrimeExponentP(),
376+
rsaSpec.getPrimeExponentQ(),
377+
rsaSpec.getCrtCoefficient()
378+
);
379+
} catch (ProviderException e) {
380+
throw new InvalidKeySpecException(e);
381+
}
373382
}
374-
} else if (keySpec instanceof RSAPrivateKeySpec rsaSpec) {
375-
try {
376-
return new RSAPrivateKeyImpl(
377-
type, rsaSpec.getParams(),
378-
rsaSpec.getModulus(),
379-
rsaSpec.getPrivateExponent()
380-
);
381-
} catch (ProviderException e) {
382-
throw new InvalidKeySpecException(e);
383+
case RSAPrivateKeySpec rsaSpec -> {
384+
try {
385+
yield new RSAPrivateKeyImpl(
386+
type, rsaSpec.getParams(),
387+
rsaSpec.getModulus(),
388+
rsaSpec.getPrivateExponent()
389+
);
390+
} catch (ProviderException e) {
391+
throw new InvalidKeySpecException(e);
392+
}
383393
}
384-
} else {
385-
throw new InvalidKeySpecException("Only RSAPrivate(Crt)KeySpec "
386-
+ "and PKCS8EncodedKeySpec supported for RSA private keys");
387-
}
394+
case null -> throw new InvalidKeySpecException(
395+
"keySpec must not be null");
396+
default ->
397+
throw new InvalidKeySpecException(keySpec.getClass().getName() +
398+
" not supported.");
399+
};
388400
}
389401

390402
protected <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec)

0 commit comments

Comments
 (0)