Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Quellcode-Bibliothek

© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: EdDSATest.java   Sprache: JAVA

/*
 * 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[]{truefalse}) {

            // 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[]{truefalse}) {
            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.27 Sekunden  (vorverarbeitet)  ¤





Download des
Quellennavigators
Download des
sprechenden Kalenders

in der Quellcodebibliothek suchen




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.


Bot Zugriff



                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik