Examples of java.security.Signature$SignatureImpl

java.security.Signature
Internal Signature implementation

                new ECPoint.Fp(curve,
                               new ECFieldElement.Fp(mod_p, new BigInteger("57520216126176808443631405023338071176630104906313632182896741342206604859403")), // x
                               new ECFieldElement.Fp(mod_p, new BigInteger("17614944419213781543809391949654080031942662045363639260709847859438286763994"))), // y
            spec);


        Signature           sgr = Signature.getInstance("ECGOST3410", "BC");
        KeyFactory          f = KeyFactory.getInstance("ECGOST3410", "BC");
        PrivateKey          sKey = f.generatePrivate(priKey);
        PublicKey           vKey = f.generatePublic(pubKey);


        sgr.initSign(sKey, k);


        byte[] message = new byte[] { (byte)'a', (byte)'b', (byte)'c' };


        sgr.update(message);


        byte[]  sigBytes = sgr.sign();


        sgr.initVerify(vKey);


        sgr.update(message);


        if (!sgr.verify(sigBytes))
        {
            fail("ECGOST3410 verification failed");
        }


        BigInteger[]  sig = decode(sigBytes);

View Full Code Here

    }


    private void generationTest()
        throws Exception
    {
        Signature             s = Signature.getInstance("GOST3410", "BC");
        KeyPairGenerator      g = KeyPairGenerator.getInstance("GOST3410", "BC");
        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);


        sigBytes = s.sign();


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


        s.initVerify(vKey);


        s.update(data);


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


        //

View Full Code Here

        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);


        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");
        }


        keyStoreTest(sKey, vKey);

View Full Code Here

            PrivateKey privKey, PublicKey pubKey, SecureRandom random) throws Exception
    {
        byte[] sampleMessage = new byte[1000 + random.nextInt(100)];
        random.nextBytes(sampleMessage);


        Signature normalSig = Signature.getInstance(sigName, "BC");


        PSSParameterSpec spec = (PSSParameterSpec)normalSig.getParameters().getParameterSpec(PSSParameterSpec.class);


        // Make sure we generate the same 'random' salt for both normal and raw signers
        int saltLen = spec.getSaltLength();
        byte[] fixedRandomBytes = new byte[saltLen];
        random.nextBytes(fixedRandomBytes);


        normalSig.initSign(privKey, new FixedSecureRandom(fixedRandomBytes));
        normalSig.update(sampleMessage);
        byte[] normalResult = normalSig.sign();


        MessageDigest digest = MessageDigest.getInstance(digestOID.getId(), "BC");
        byte[] hash = digest.digest(sampleMessage);


        Signature rawSig = Signature.getInstance("RAWRSASSA-PSS", "BC");


        // Need to init the params explicitly to avoid having a 'raw' variety of every PSS algorithm
        rawSig.setParameter(spec);


        rawSig.initSign(privKey, new FixedSecureRandom(fixedRandomBytes));
        rawSig.update(hash);
        byte[] rawResult = rawSig.sign();


        if (!Arrays.areEqual(normalResult, rawResult))
        {
            fail("raw mode signature differs from normal one");
        }


        rawSig.initVerify(pubKey);
        rawSig.update(hash);


        if (!rawSig.verify(rawResult))
        {
            fail("raw mode signature verification failed");
        }
    }

View Full Code Here


        ECPublicKeySpec pubKey = new ECPublicKeySpec(
            ECPointUtil.decodePoint(curve, Hex.decode("025b6dc53bc61a2548ffb0f671472de6c9521a9d2d2534e65abfcbd5fe0c70")), // Q
            spec);


        Signature           sgr = Signature.getInstance("ECDSA", "BC");
        KeyFactory          f = KeyFactory.getInstance("ECDSA", "BC");
        PrivateKey          sKey = f.generatePrivate(priKey);
        PublicKey           vKey = f.generatePublic(pubKey);


        sgr.initSign(sKey, k);


        byte[] message = new byte[] { (byte)'a', (byte)'b', (byte)'c' };


        sgr.update(message);


        byte[]  sigBytes = sgr.sign();


        sgr.initVerify(vKey);


        sgr.update(message);


        if (!sgr.verify(sigBytes))
        {
            fail("239 Bit EC verification failed");
        }


        BigInteger[]  sig = derDecode(sigBytes);

View Full Code Here

        
        ECPublicKeySpec pubKeySpec = new ECPublicKeySpec(
            ECPointUtil.decodePoint(curve, Hex.decode("045894609CCECF9A92533F630DE713A958E96C97CCB8F5ABB5A688A238DEED6DC2D9D0C94EBFB7D526BA6A61764175B99CB6011E2047F9F067293F57F5")), // Q
            params);
    
        Signature   sgr = Signature.getInstance("ECDSA", "BC");
        KeyFactory  f = KeyFactory.getInstance("ECDSA", "BC");
        PrivateKey  sKey = f.generatePrivate(priKeySpec);
        PublicKey   vKey = f.generatePublic(pubKeySpec);
        byte[]      message = new byte[] { (byte)'a', (byte)'b', (byte)'c' };
       
        sgr.initSign(sKey, k);


        sgr.update(message);
        
        byte[]  sigBytes = sgr.sign();


        sgr.initVerify(vKey);


        sgr.update(message);


        if (!sgr.verify(sigBytes))
        {
            fail("239 Bit EC verification failed");
        }


        BigInteger[]  sig = derDecode(sigBytes);

View Full Code Here

    {
        //
        // ECDSA generation test
        //
        byte[]              data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        Signature s = Signature.getInstance("ECDSA", "BC");
        KeyPairGenerator g = KeyPairGenerator.getInstance("ECDSA", "BC");


        EllipticCurve curve = new EllipticCurve(
            new ECFieldFp(new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839")), // q
            new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a
            new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b


        ECParameterSpec ecSpec = new ECParameterSpec(
            curve,
            ECPointUtil.decodePoint(curve, Hex.decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G
            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);


        byte[] sigBytes = s.sign();


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


        s.initVerify(vKey);


        s.update(data);


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


        testKeyFactory((ECPublicKey)vKey, (ECPrivateKey)sKey);

View Full Code Here

        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()
            {
                public String getAlgorithm()
                {
                    return privRsa.getAlgorithm();
                }


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


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


            fail("no exception thrown!!!");


        }
        catch (InvalidKeyException e)
        {
            // ignore
        }


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

View Full Code Here


        ECPublicKeySpec pubKey = new ECPublicKeySpec(
            curve.decodePoint(Hex.decode("025b6dc53bc61a2548ffb0f671472de6c9521a9d2d2534e65abfcbd5fe0c70")), // Q
            spec);


        Signature           sgr = Signature.getInstance("SHA1withECNR", "BC");
        KeyFactory          f = KeyFactory.getInstance("ECDSA", "BC");


        byte[] message = new byte[] { (byte)'a', (byte)'b', (byte)'c' };
        
        checkSignature(239, priKey, pubKey, sgr, k, message, r, s);

View Full Code Here


        ECPublicKeySpec pubKey = new ECPublicKeySpec(
            curve.decodePoint(Hex.decode("0262B12D60690CDCF330BABAB6E69763B471F994DD702D16A5")), // Q
            spec);


        Signature           sgr = Signature.getInstance("SHA1withECNR", "BC");
        KeyFactory          f = KeyFactory.getInstance("ECDSA", "BC");


        byte[] message = new byte[] { (byte)'a', (byte)'b', (byte)'c' };
        
        checkSignature(192, priKey, pubKey, sgr, k, message, r, s);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.security.Signature$SignatureImpl

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

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

ch.ethz.prose.SignedAspect

cn.featherfly.common.algorithm.RSA

com.aelitis.azureus.core.security.impl.CryptoHandlerECC

com.aelitis.azureus.core.security.impl.CryptoSTSEngineImpl

com.aelitis.azureus.core.subs.impl.SubscriptionBodyImpl

com.aelitis.azureus.plugins.dht.impl.DHTPluginStorageManager

com.android.builder.signing.SignedJarBuilder

com.atlassian.connect.play.java.plugin.KeyPairPlugin

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.