Examples of java.security.KeyPair

java.security.KeyPair
This class is a simple holder for a key pair (a public key and a private key). It does not enforce any security, and, when initialized, should be treated like a PrivateKey. @see PublicKey @see PrivateKey @version 1.16 05/11/17 @author Benjamin Renaud

        keyPairGen.initialize(
            new RSAKeyGenParameterSpec(768,
            BigInteger.valueOf(65537)),
            new SecureRandom());


        KeyPair kp = keyPairGen.generateKeyPair();


        pubKey = kp.getPublic();
        privKey = kp.getPrivate();


        c.init(Cipher.ENCRYPT_MODE, pubKey, rand);


        out = c.doFinal(input);

View Full Code Here

        byte[]                data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        GOST3410ParameterSpec gost3410P = new GOST3410ParameterSpec(CryptoProObjectIdentifiers.gostR3410_94_CryptoPro_A.getId());


        g.initialize(gost3410P, new SecureRandom());


        KeyPair p = g.generateKeyPair();


        PrivateKey  sKey = p.getPrivate();
        PublicKey   vKey = p.getPublic();


        s.initSign(sKey);


        s.update(data);


        byte[]  sigBytes = s.sign();


        s = Signature.getInstance("GOST3410", "BC");


        s.initVerify(vKey);


        s.update(data);


        if (!s.verify(sigBytes))
        {
            fail("GOST3410 verification failed");
        }


        //
        // default initialisation test
        //
        s = Signature.getInstance("GOST3410", "BC");
        g = KeyPairGenerator.getInstance("GOST3410", "BC");


        p = g.generateKeyPair();


        sKey = p.getPrivate();
        vKey = p.getPublic();


        s.initSign(sKey);


        s.update(data);


        sigBytes = s.sign();


        s = Signature.getInstance("GOST3410", "BC");


        s.initVerify(vKey);


        s.update(data);


        if (!s.verify(sigBytes))
        {
            fail("GOST3410 verification failed");
        }


        //
        // encoded test
        //
        KeyFactory f = KeyFactory.getInstance("GOST3410", "BC");


        X509EncodedKeySpec  x509s = new X509EncodedKeySpec(vKey.getEncoded());
        GOST3410PublicKey   k1 = (GOST3410PublicKey)f.generatePublic(x509s);


        if (!k1.getY().equals(((GOST3410PublicKey)vKey).getY()))
        {
            fail("public number not decoded properly");
        }


        if (!k1.getParameters().equals(((GOST3410PublicKey)vKey).getParameters()))
        {
            fail("public parameters not decoded properly");
        }


        PKCS8EncodedKeySpec  pkcs8 = new PKCS8EncodedKeySpec(sKey.getEncoded());
        GOST3410PrivateKey   k2 = (GOST3410PrivateKey)f.generatePrivate(pkcs8);


        if (!k2.getX().equals(((GOST3410PrivateKey)sKey).getX()))
        {
            fail("private number not decoded properly");
        }


        if (!k2.getParameters().equals(((GOST3410PrivateKey)sKey).getParameters()))
        {
            fail("private number not decoded properly");
        }


        k2 = (GOST3410PrivateKey)serializeDeserialize(sKey);
        if (!k2.getX().equals(((GOST3410PrivateKey)sKey).getX()))
        {
            fail("private number not deserialised properly");
        }


        if (!k2.getParameters().equals(((GOST3410PrivateKey)sKey).getParameters()))
        {
            fail("private number not deserialised properly");
        }


        checkEquals(k2, sKey);


        if (!(k2 instanceof PKCS12BagAttributeCarrier))
        {
            fail("private key not implementing PKCS12 attribute carrier");
        }


        k1 = (GOST3410PublicKey)serializeDeserialize(vKey);


        if (!k1.getY().equals(((GOST3410PublicKey)vKey).getY()))
        {
            fail("public number not deserialised properly");
        }


        if (!k1.getParameters().equals(((GOST3410PublicKey)vKey).getParameters()))
        {
            fail("public parameters not deserialised properly");
        }


        checkEquals(k1, vKey);


        //
        // ECGOST3410 generation test
        //
        s = Signature.getInstance("ECGOST3410", "BC");
        g = KeyPairGenerator.getInstance("ECGOST3410", "BC");


//        BigInteger mod_p = new BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564821041"); //p
//
//        ECCurve curve = new ECCurve.Fp(
//            mod_p, // p
//            new BigInteger("7"), // a
//            new BigInteger("43308876546767276905765904595650931995942111794451039583252968842033849580414")); // b
//
//        ECParameterSpec ecSpec = new ECParameterSpec(
//                curve,
//                    new ECPoint.Fp(curve,
//                                   new ECFieldElement.Fp(mod_p,new BigInteger("2")), // x
//                                   new ECFieldElement.Fp(mod_p,new BigInteger("4018974056539037503335449422937059775635739389905545080690979365213431566280"))), // y
//                    new BigInteger("57896044618658097711785492504343953927082934583725450622380973592137631069619")); // q


        g.initialize(new ECNamedCurveGenParameterSpec("GostR3410-2001-CryptoPro-A"), new SecureRandom());


        p = g.generateKeyPair();


        sKey = p.getPrivate();
        vKey = p.getPublic();


        s.initSign(sKey);


        s.update(data);

View Full Code Here


        GOST3410ParameterSpec gost3410P = new GOST3410ParameterSpec(CryptoProObjectIdentifiers.gostR3410_94_CryptoPro_B.getId());


        KeyPairGenerator    g = KeyPairGenerator.getInstance("GOST3410", "BC");
        g.initialize(gost3410P, new SecureRandom());
        KeyPair p = g.generateKeyPair();


        PrivateKey  sKey = p.getPrivate();
        PublicKey   vKey = p.getPublic();


        Signature           s = Signature.getInstance("GOST3410", "BC");
        byte[]              data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };


        s.initSign(sKey);

View Full Code Here

        byte[] out1, out2;
  
        Cipher        c1 = Cipher.getInstance(cipher, "BC");
        Cipher        c2 = Cipher.getInstance(cipher, "BC");
        // Generate static key pair
        KeyPair       keyPair = g.generateKeyPair();
        DHPublicKey   pub = (DHPublicKey)keyPair.getPublic();
        DHPrivateKey  priv = (DHPrivateKey)keyPair.getPrivate();
       


        // Testing with null parameters and DHAES mode off
        c1.init(Cipher.ENCRYPT_MODE, pub, new SecureRandom());
        c2.init(Cipher.DECRYPT_MODE, priv, new SecureRandom());

View Full Code Here

    {
        KeyPairGenerator kpGen = KeyPairGenerator.getInstance("ECDSA", "BC");


        kpGen.initialize(new ECGenParameterSpec("prime192v1"));


        KeyPair pair = kpGen.generateKeyPair();


        PublicKey pubKey = ECKeyUtil.publicToExplicitParameters(pair.getPublic(), "BC");


        SubjectPublicKeyInfo info = SubjectPublicKeyInfo.getInstance(ASN1Primitive.fromByteArray(pubKey.getEncoded()));
        X962Parameters params = X962Parameters.getInstance(info.getAlgorithmId().getParameters());


        if (params.isNamedCurve() || params.isImplicitlyCA())
        {
            fail("public key conversion to explicit failed");
        }


        if (!((ECPublicKey)pair.getPublic()).getW().equals(((ECPublicKey)pubKey).getW()))
        {
            fail("public key conversion check failed");
        }


        PrivateKey privKey = ECKeyUtil.privateToExplicitParameters(pair.getPrivate(), "BC");
        PrivateKeyInfo privInfo = PrivateKeyInfo.getInstance(ASN1Primitive.fromByteArray(privKey.getEncoded()));
        params = X962Parameters.getInstance(privInfo.getAlgorithmId().getParameters());


        if (params.isNamedCurve() || params.isImplicitlyCA())
        {
            fail("private key conversion to explicit failed");
        }


        if (!((ECPrivateKey)pair.getPrivate()).getS().equals(((ECPrivateKey)privKey).getS()))
        {
            fail("private key conversion check failed");
        }
    }

View Full Code Here

    {
        KeyPairGenerator kpGen = KeyPairGenerator.getInstance("ECDSA", "BC");


        kpGen.initialize(new ECGenParameterSpec("prime192v1"));


        KeyPair pair = kpGen.generateKeyPair();


        final PrivateKey privKey = pair.getPrivate();
        final PublicKey  pubKey = pair.getPublic();


        Signature s = Signature.getInstance("ECDSA", "BC");


        // raw interface tests
        s.initSign(new PrivateKey()
        {
            public String getAlgorithm()
            {
                return privKey.getAlgorithm();
            }


            public String getFormat()
            {
                return privKey.getFormat();
            }


            public byte[] getEncoded()
            {
                return privKey.getEncoded();
            }
        });


        s.initVerify(new PublicKey()
        {
            public String getAlgorithm()
            {
                return pubKey.getAlgorithm();
            }


            public String getFormat()
            {
                return pubKey.getFormat();
            }


            public byte[] getEncoded()
            {
                return pubKey.getEncoded();
            }
        });




        s.initSign(new ECPrivateKey()
        {
            public String getAlgorithm()
            {
                return privKey.getAlgorithm();
            }


            public String getFormat()
            {
                return privKey.getFormat();
            }


            public byte[] getEncoded()
            {
                return privKey.getEncoded();
            }


            public BigInteger getS()
            {
                return ((ECPrivateKey)privKey).getS();
            }


            public ECParameterSpec getParams()
            {
                return ((ECPrivateKey)privKey).getParams();
            }
        });


        s.initVerify(new ECPublicKey()
        {
            public String getAlgorithm()
            {
                return pubKey.getAlgorithm();
            }


            public String getFormat()
            {
                return pubKey.getFormat();
            }


            public byte[] getEncoded()
            {
                return pubKey.getEncoded();
            }


            public ECPoint getW()
            {
                return ((ECPublicKey)pubKey).getW();
            }


            public ECParameterSpec getParams()
            {
                return ((ECPublicKey)pubKey).getParams();
            }
        });


        try
        {
            s.initSign(new PrivateKey()
            {
                public String getAlgorithm()
                {
                    return privKey.getAlgorithm();
                }


                public String getFormat()
                {
                    return privKey.getFormat();
                }


                public byte[] getEncoded()
                {
                    return null;
                }
            });


            fail("no exception thrown!!!");
        }
        catch (InvalidKeyException e)
        {
            // ignore
        }


        try
        {
            s.initVerify(new PublicKey()
            {
                public String getAlgorithm()
                {
                    return pubKey.getAlgorithm();
                }


                public String getFormat()
                {
                    return pubKey.getFormat();
                }


                public byte[] getEncoded()
                {
                    return null;
                }
            });


            fail("no exception thrown!!!");
        }
        catch (InvalidKeyException e)
        {
            // ignore
        }


        // try bogus encoding
        try
        {
            s.initSign(new PrivateKey()
            {
                public String getAlgorithm()
                {
                    return privKey.getAlgorithm();
                }


                public String getFormat()
                {
                    return privKey.getFormat();
                }


                public byte[] getEncoded()
                {
                    return new byte[20];
                }
            });


            fail("no exception thrown!!!");
        }
        catch (InvalidKeyException e)
        {
            // ignore
        }


        try
        {
            s.initVerify(new PublicKey()
            {
                public String getAlgorithm()
                {
                    return pubKey.getAlgorithm();
                }


                public String getFormat()
                {
                    return pubKey.getFormat();
                }


                public byte[] getEncoded()
                {
                    return new byte[20];
                }
            });


            fail("no exception thrown!!!");
        }
        catch (InvalidKeyException e)
        {
            // ignore
        }


        // try encoding of wrong key
        kpGen = KeyPairGenerator.getInstance("RSA", "BC");


        kpGen.initialize(512);


        pair = kpGen.generateKeyPair();


        final PrivateKey privRsa = pair.getPrivate();
        final PublicKey  pubRsa = pair.getPublic();


        try
        {
            s.initSign(new PrivateKey()
            {

View Full Code Here

            new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307"), // n
            1); // h


        g.initialize(ecSpec, new SecureRandom());


        KeyPair p = g.generateKeyPair();


        PrivateKey sKey = p.getPrivate();
        PublicKey  vKey = p.getPublic();


        s.initSign(sKey);


        s.update(data);

View Full Code Here


        KeyPairGenerator    g = KeyPairGenerator.getInstance("ECDSA", "BC");


        g.initialize(ecSpec, new SecureRandom());


        KeyPair     keyPair = g.generateKeyPair();


        PublicKey   pubKey = keyPair.getPublic();
        PrivateKey  privKey = keyPair.getPrivate();


        //
        // distinguished name table.
        //
        Hashtable                 attrs = new Hashtable();

View Full Code Here


        KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA", "BC");


        gen.initialize(1024, new SecureRandom());


        KeyPair         pair = gen.generateKeyPair();
        RSAPrivateKey   privKey = (RSAPrivateKey)pair.getPrivate();
        RSAPublicKey    pubKey = (RSAPublicKey)pair.getPublic();
        BigInteger      modulus = privKey.getModulus();
        BigInteger      privateExponent = privKey.getPrivateExponent();




        //

View Full Code Here


        config.setParameter(ConfigurableProvider.EC_IMPLICITLY_CA, ecSpec);


        g.initialize(null, new SecureRandom());


        KeyPair p = g.generateKeyPair();


        ECPrivateKey sKey = (ECPrivateKey)p.getPrivate();
        ECPublicKey vKey = (ECPublicKey)p.getPublic();


        testECDSA(sKey, vKey);


        testBCParamsAndQ(sKey, vKey);
        testEC5Params(sKey, vKey);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.security.KeyPair

br.net.woodstock.rockframework.security.cert.impl.BouncyCastleCertificateBuilder

br.net.woodstock.rockframework.security.crypt.impl.CrypterHelper

br.net.woodstock.rockframework.security.sign.impl.JCASigner

cn.featherfly.common.algorithm.RSA

com.aelitis.azureus.core.networkmanager.impl.ProtocolDecoderPHE

com.alibaba.druid.filter.config.ConfigTools

com.btmatthews.maven.plugins.crx.CRXArchiverImpl

com.drighetto.essai.bouncycastle.certificate.CertificateGenerator

com.gitblit.utils.X509Utils

com.sequenceiq.cloudbreak.service.stack.connector.gcc.GccStackUtil

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.