|
/*
* Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import static javax.crypto.Cipher.PRIVATE_KEY;
import static javax.crypto.Cipher.PUBLIC_KEY;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.interfaces.EdECPrivateKey;
import java.security.interfaces.EdECPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.security.spec.EdECPrivateKeySpec;
import java.security.spec.EdECPublicKeySpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.NamedParameterSpec;
import java.security.spec.EdDSAParameterSpec;
import java.util.Arrays;
import java.util.HexFormat;
/*
* @test
* @bug 8209632
* @summary Test Signature with variation of serialized EDDSA Keys.
* @library /test/lib
* @build jdk.test.lib.Convert
* @run main EdDSATest
*/
public class EdDSATest {
private static final String EDDSA = "EdDSA";
private static final String ED25519 = "Ed25519";
private static final String ED448 = "Ed448";
private static final String OIDN25519 = "1.3.101.112";
private static final String OID25519 = "OID.1.3.101.112";
private static final String OIDN448 = "1.3.101.113";
private static final String OID448 = "OID.1.3.101.113";
private static final String PROVIDER = "SunEC";
private static final byte[] MSG = "TEST".getBytes();
private static final SecureRandom S_RND = new SecureRandom(new byte[]{0x1});
public static void main(String[] args) throws Exception {
for (boolean random : new boolean[]{true, false}) {
// Default Parameter
test(PROVIDER, EDDSA, null, random);
test(PROVIDER, ED25519, null, random);
test(PROVIDER, ED448, null, random);
// With named parameter
test(PROVIDER, EDDSA, ED25519, random);
test(PROVIDER, ED25519, ED25519, random);
test(PROVIDER, OIDN25519, ED25519, random);
test(PROVIDER, OID25519, ED25519, random);
test(PROVIDER, ED448, ED448, random);
test(PROVIDER, OIDN448, ED448, random);
test(PROVIDER, OID448, ED448, random);
// With size parameter
test(PROVIDER, EDDSA, 255, random);
test(PROVIDER, ED25519, 255, random);
test(PROVIDER, OIDN25519, 255, random);
test(PROVIDER, OID25519, 255, random);
test(PROVIDER, ED448, 448, random);
test(PROVIDER, OIDN448, 448, random);
test(PROVIDER, OID448, 448, random);
}
}
// Test signature using a KeyPair and the corresponding transformed one.
private static void test(String provider, String name, Object param,
boolean random) throws Exception {
System.out.printf("Case Algo:%s, Param:%s, Intitiate with random:%s%n",
name, param, random);
KeyPair origkp = genKeyPair(provider, name, param, random);
testSignature(provider, name, origkp, origkp);
NamedParameterSpec namedSpec = namedParamSpec(name);
// Test all possible transformed private/public keys
for (Key priKey : manipulateKey(provider, name, PRIVATE_KEY,
origkp.getPrivate(), namedSpec)) {
for (Key pubKey : manipulateKey(provider, name, PUBLIC_KEY,
origkp.getPublic(), namedSpec)) {
EdECPrivateKey pri = (EdECPrivateKey) priKey;
EdECPublicKey pub = (EdECPublicKey) pubKey;
// Test the keys are serializable.
testSerialize(origkp, new KeyPair(pub, pri));
// Test signature
testSignature(provider, name, origkp, new KeyPair(pub, pri));
}
}
System.out.println("Passed.");
}
private static KeyPair genKeyPair(String provider, String name,
Object param, boolean random) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(name, provider);
if (random) {
if (param instanceof Integer) {
kpg.initialize((Integer) param, S_RND);
} else if (param instanceof String) {
kpg.initialize(new NamedParameterSpec((String) param), S_RND);
}
} else {
if (param instanceof Integer) {
kpg.initialize((Integer) param);
} else if (param instanceof String) {
kpg.initialize(new NamedParameterSpec((String) param));
}
}
equals(kpg.getProvider().getName(), provider);
equals(kpg.getAlgorithm(), name);
return kpg.generateKeyPair();
}
private static NamedParameterSpec namedParamSpec(String algo) {
NamedParameterSpec namedSpec = switch (algo) {
case EDDSA
, OIDN25519, OID25519 -> new NamedParameterSpec(ED25519);
case OIDN448
, OID448 -> new NamedParameterSpec(ED448);
default->
new NamedParameterSpec(algo);
};
return namedSpec;
}
private static Key[] manipulateKey(String provider, String name, int type,
Key key, NamedParameterSpec namedSpec)
throws NoSuchAlgorithmException, InvalidKeySpecException,
NoSuchProviderException, InvalidKeyException {
KeyFactory kf = KeyFactory.getInstance(name, provider);
switch (type) {
case PUBLIC_KEY:
return new Key[]{
kf.generatePublic(new X509EncodedKeySpec(key.getEncoded())),
kf.generatePublic(kf.getKeySpec(
key, EdECPublicKeySpec.class)),
kf.generatePublic(new EdECPublicKeySpec(namedSpec,
((EdECPublicKey) key).getPoint())),
kf.translateKey(key)
};
case PRIVATE_KEY:
return new Key[]{
kf.generatePrivate(new PKCS8EncodedKeySpec(key.getEncoded())),
kf.generatePrivate(
kf.getKeySpec(key, EdECPrivateKeySpec.class)),
kf.generatePrivate(new EdECPrivateKeySpec(namedSpec,
((EdECPrivateKey) key).getBytes().get())),
kf.translateKey(key)
};
}
throw new RuntimeException("We shouldn't reach here");
}
/**
* Test Signature with a set of parameter combination.
*/
private static void testSignature(String provider, String name,
KeyPair origkp, KeyPair kp) throws Exception {
signAndVerify(provider, name, origkp, kp, null);
// Test Case with Pre-Hash enabled and disabled.
for (boolean preHash : new boolean[]{true, false}) {
signAndVerify(provider, name, origkp, kp,
new EdDSAParameterSpec(preHash));
// Test Case with Context combined.
for (byte[] context : new byte[][]{
{}, "a".getBytes(), new byte[255]}) {
signAndVerify(provider, name, origkp, kp,
new EdDSAParameterSpec(preHash, context));
}
}
}
private static void signAndVerify(String provider, String name,
KeyPair origkp, KeyPair kp, EdDSAParameterSpec params)
throws Exception {
Signature sig = Signature.getInstance(name, provider);
if (params != null) {
sig.setParameter(params);
}
sig.initSign(origkp.getPrivate());
sig.update(MSG);
byte[] origSign = sig.sign();
sig.update(MSG);
byte[] computedSig = sig.sign();
equals(origSign, computedSig);
// EdDSA signatures size (64 and 114 bytes) for Ed25519 and Ed448.
int expectedSigSize = edSignatureSize(name);
equals(origSign.length, expectedSigSize);
sig.initSign(kp.getPrivate());
sig.update(MSG);
equals(computedSig, sig.sign());
// Use same signature instance to verify with transformed PublicKey.
sig.initVerify(kp.getPublic());
sig.update(MSG);
if (!sig.verify(origSign)) {
throw new RuntimeException(String.format("Signature did not verify"
+ " for name:%s, prehash:%s, context:%s", name,
(params == null) ? null : params.isPrehash(),
(params == null) ? null : params.getContext().get()));
}
// Create a new signature to re-verify.
sig = Signature.getInstance(name, provider);
if (params != null) {
sig.setParameter(params);
}
// Verify the signature with transformed PublicKey.
sig.initVerify(kp.getPublic());
sig.update(MSG);
if (!sig.verify(origSign)) {
throw new RuntimeException(String.format("Signature did not verify"
+ " for name:%s, prehash:%s, context:%s",
name, (params == null) ? null : params.isPrehash(),
(params == null) ? null : params.getContext().get()));
}
equals(sig.getAlgorithm(), name);
equals(sig.getProvider().getName(), provider);
}
private static int edSignatureSize(String algo) {
int size = switch (algo) {
case EDDSA
, ED25519, OIDN25519, OID25519 -> 64;
case ED448
, OIDN448, OID448 -> 114;
default->
-1;
};
return size;
}
/**
* Compare original KeyPair with transformed ones.
*/
private static void testKeyEquals(KeyPair origkp, PublicKey pubKey,
PrivateKey priKey) {
if (!origkp.getPrivate().equals(priKey)
&& !Arrays.equals(origkp.getPrivate().getEncoded(),
priKey.getEncoded())
&& origkp.getPrivate().hashCode() != priKey.hashCode()) {
throw new RuntimeException(
"PrivateKey is not equal with transformed one");
}
if (!origkp.getPublic().equals(pubKey)
&& !Arrays.equals(origkp.getPublic().getEncoded(),
pubKey.getEncoded())
&& origkp.getPublic().hashCode() != pubKey.hashCode()) {
throw new RuntimeException(
"PublicKey is not equal with transformed one");
}
}
/**
* Test serialization of KeyPair and Keys.
*/
private static void testSerialize(KeyPair origkp, KeyPair kp)
throws Exception {
testKeyEquals(origkp, kp.getPublic(), kp.getPrivate());
PrivateKey priv = deserializedCopy(kp.getPrivate(), PrivateKey.class);
PublicKey pub = deserializedCopy(kp.getPublic(), PublicKey.class);
testKeyEquals(origkp, pub, priv);
// Verify Serialized KeyPair instance.
KeyPair copy = deserializedCopy(kp, KeyPair.class);
testKeyEquals(origkp, copy.getPublic(), copy.getPrivate());
}
private static <T extends Object> T deserializedCopy(T origkp, Class<T> type)
throws IOException, ClassNotFoundException {
return deserialize(serialize(origkp), type);
}
/**
* Deserialize the Key object.
*/
private static <T extends Object> T deserialize(byte[] serialized,
Class<T> type) throws IOException, ClassNotFoundException {
T key = null;
try (ByteArrayInputStream bis = new ByteArrayInputStream(serialized);
ObjectInputStream ois = new ObjectInputStream(bis)) {
key = (T) ois.readObject();
}
return key;
}
/**
* Serialize the given Key object.
*/
private static <T extends Object> byte[] serialize(T key)
throws IOException {
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos)) {
oos.writeObject(key);
return bos.toByteArray();
}
}
private static void equals(Object actual, Object expected) {
if (!actual.equals(expected)) {
throw new RuntimeException(String.format("Actual: %s, Expected: %s",
actual, expected));
}
}
private static void equals(byte[] actual, byte[] expected) {
if (!Arrays.equals(actual, expected)) {
throw new RuntimeException(String.format("Actual array: %s, "
+ "Expected array:%s", HexFormat.of().withUpperCase().formatHex(actual),
HexFormat.of().withUpperCase().formatHex(expected)));
}
}
}
¤ Dauer der Verarbeitung: 0.20 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
