| /* | |
| * Copyright (c) 2020, 2024, 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 = System.getProperty("test.provider.name", "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))); | |
| } | |
| } | |
| } |