| /* | |
| * 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 java.security.KeyPair; | |
| import java.security.KeyPairGenerator; | |
| import java.security.PrivateKey; | |
| import java.security.PublicKey; | |
| import java.security.SecureRandom; | |
| import java.security.Signature; | |
| import java.security.spec.EdDSAParameterSpec; | |
| import java.util.Arrays; | |
| import java.util.HexFormat; | |
| /* | |
| * @test | |
| * @bug 8209632 | |
| * @summary Test EdDSAParameterSpec. | |
| * @library /test/lib | |
| * @build jdk.test.lib.Convert | |
| * @run main EdDSAParamSpec | |
| */ | |
| public class EdDSAParamSpec { | |
| private static final String EDDSA = "EdDSA"; | |
| private static final String ED25519 = "Ed25519"; | |
| private static final String ED448 = "Ed448"; | |
| private static final String PROVIDER = System.getProperty("test.provider.name", "SunEC"); | |
| private static final byte[] MSG = "TEST".getBytes(); | |
| private static final SecureRandom RND = new SecureRandom(new byte[]{0x1}); | |
| public static void main(String[] args) throws Exception { | |
| testParam(PROVIDER, EDDSA); | |
| testParam(PROVIDER, ED25519); | |
| testParam(PROVIDER, ED448); | |
| } | |
| /** | |
| * Test Signature. | |
| */ | |
| private static void testParam(String provider, String name) | |
| throws Exception { | |
| KeyPair kp = genKeyPair(provider, name); | |
| Signature sig = Signature.getInstance(name, provider); | |
| EdDSAParameterSpec initParam | |
| = new EdDSAParameterSpec(true, "testContext".getBytes()); | |
| sig.setParameter(initParam); | |
| byte[] origSign = sign(sig, kp.getPrivate(), MSG); | |
| for (boolean preHash : new boolean[]{true, false}) { | |
| System.out.printf("Testing signature for name: %s," | |
| + " algorithm spec: (prehash:%s)%n", name, preHash); | |
| verifyPublic(sig, kp.getPublic(), MSG, | |
| new EdDSAParameterSpec(preHash), initParam, origSign); | |
| // Test Case with Context size combined. | |
| // As per rfc8032, value of context is maximum of 255 octet | |
| byte[] maxCtx = new byte[255]; | |
| RND.nextBytes(maxCtx); | |
| for (byte[] context : new byte[][]{"others".getBytes(), maxCtx}) { | |
| System.out.printf("Testing signature for name: %s," | |
| + " algorithm spec: (prehash:%s, context:%s)%n", | |
| name, preHash, HexFormat.of().withUpperCase().formatHex(context)); | |
| EdDSAParameterSpec params | |
| = new EdDSAParameterSpec(preHash, context); | |
| verifyPublic(sig, kp.getPublic(), MSG, params, initParam, | |
| origSign); | |
| } | |
| } | |
| System.out.println("Passed."); | |
| } | |
| private static KeyPair genKeyPair(String provider, String name) | |
| throws Exception { | |
| KeyPairGenerator kpg = KeyPairGenerator.getInstance(name, provider); | |
| return kpg.generateKeyPair(); | |
| } | |
| private static byte[] sign(Signature sig, PrivateKey priKey, byte[] msg) | |
| throws Exception { | |
| sig.initSign(priKey); | |
| sig.update(msg); | |
| return sig.sign(); | |
| } | |
| private static boolean verify(Signature sig, PublicKey pubKey, byte[] msg, | |
| byte[] sign) throws Exception { | |
| sig.initVerify(pubKey); | |
| sig.update(msg); | |
| return sig.verify(sign); | |
| } | |
| private static void verifyPublic(Signature sig, PublicKey pubKey, | |
| byte[] msg, EdDSAParameterSpec params, EdDSAParameterSpec initParam, | |
| byte[] origSign) throws Exception { | |
| sig.setParameter(params); | |
| if (verify(sig, pubKey, msg, origSign)) { | |
| byte[] context = params.getContext().isPresent() | |
| ? params.getContext().get() : null; | |
| byte[] initContext = initParam.getContext().isPresent() | |
| ? initParam.getContext().get() : null; | |
| boolean preHash = params.isPrehash(); | |
| boolean initPreHash = initParam.isPrehash(); | |
| // The signature should not get verified other than same parameter | |
| // which is set through the signature instance. | |
| if (!(equals(context, initContext) && equals(preHash, initPreHash))) { | |
| throw new RuntimeException(String.format("Signature verification" | |
| + " success with different param context(actual:%s, " | |
| + "expected:%s), Prehash(actual:%s, expected:%s)", | |
| HexFormat.of().withUpperCase().formatHex(context), | |
| HexFormat.of().withUpperCase().formatHex(initContext), | |
| preHash, initPreHash)); | |
| } else { | |
| System.out.println("Atleast a case matched"); | |
| } | |
| } | |
| } | |
| private static boolean equals(Object actual, Object expected) { | |
| if (actual == expected) { | |
| return true; | |
| } | |
| if (actual == null || expected == null) { | |
| return false; | |
| } | |
| boolean equals = actual.equals(expected); | |
| if (!equals) { | |
| throw new RuntimeException(String.format("Actual: %s, Expected: %s", | |
| actual, expected)); | |
| } | |
| return equals; | |
| } | |
| private static boolean equals(byte[] actual, byte[] expected) { | |
| if (actual == expected) { | |
| return true; | |
| } | |
| if (actual == null || expected == null) { | |
| return false; | |
| } | |
| boolean equals = Arrays.equals(actual, expected); | |
| if (!equals) { | |
| throw new RuntimeException(String.format("Actual array: %s, " | |
| + "Expected array:%s", HexFormat.of().withUpperCase().formatHex(actual), | |
| HexFormat.of().withUpperCase().formatHex(expected))); | |
| } | |
| return equals; | |
| } | |
| } |