Examples of java.security.Signature$CipherAdapter

java.security.Signature
This Signature class is used to provide applications the functionality of a digital signature algorithm. Digital signatures are used for authentication and integrity assurance of digital data.
The signature algorithm can be, among others, the NIST standard DSA, using DSA and SHA-1. The DSA algorithm using the SHA-1 message digest algorithm can be specified as SHA1withDSA. In the case of RSA, there are multiple choices for the message digest algorithm, so the signing algorithm could be specified as, for example, MD2withRSA, MD5withRSA, or SHA1withRSA. The algorithm name must be specified, as there is no default.
A Signature object can be used to generate and verify digital signatures.
There are three phases to the use of a Signature object for either signing data or verifying a signature:
1. Initialization, with either
  - a public key, which initializes the signature for verification (see {@link #initVerify(PublicKey) initVerify}), or
  - a private key (and optionally a Secure Random Number Generator), which initializes the signature for signing (see {@link #initSign(PrivateKey)}and {@link #initSign(PrivateKey,SecureRandom)}).
2. Updating
  
  Depending on the type of initialization, this will update the bytes to be signed or verified. See the {@link #update(byte) update} methods.
3. Signing or Verifying a signature on all updated bytes. See the {@link #sign() sign} methods and the {@link #verify(byte[]) verify}method.
Note that this class is abstract and extends from SignatureSpi for historical reasons. Application developers should only take notice of the methods defined in this Signature class; all the methods in the superclass are intended for cryptographic service providers who wish to supply their own implementations of digital signature algorithms. @author Benjamin Renaud @version 1.103, 04/21/06

        urlEncodedRedirectMessage.setSignature(urlEncodedSignature);
    }


    private byte[] computeSignature(String stringToBeSigned, PrivateKey signingKey) throws GeneralSecurityException {
        String algo = signingKey.getAlgorithm();
        Signature sig = getSignature(algo);
        sig.initSign(signingKey);
        sig.update(stringToBeSigned.getBytes());
        return sig.sign();
    }

View Full Code Here

        }
    }


    private boolean validate(byte[] signedContent, byte[] signatureValue, PublicKey validatingKey) throws GeneralSecurityException {
        String algo = validatingKey.getAlgorithm();
        Signature sig = getSignature(algo);


        sig.initVerify(validatingKey);
        sig.update(signedContent);
        return sig.verify(signatureValue);
    }

View Full Code Here

        sig.update(signedContent);
        return sig.verify(signatureValue);
    }


    private Signature getSignature(String algo) throws GeneralSecurityException {
        Signature sig = null;


        if ("DSA".equalsIgnoreCase(algo)) {
            sig = Signature.getInstance(SamlConstants.DSA_SIGNATURE_ALGORITHM);
        } else if ("RSA".equalsIgnoreCase(algo)) {
            sig = Signature.getInstance(SamlConstants.RSA_SIGNATURE_ALGORITHM);

View Full Code Here

    public void proveIdentity(byte[] sharedSecret, KeyPair key) throws IOException, GeneralSecurityException {
        String algorithm = detectKeyAlgorithm(key);
        writeUTF(algorithm);
        writeKey(key.getPublic());


        Signature sig = Signature.getInstance("SHA1with"+algorithm);
        sig.initSign(key.getPrivate());
        sig.update(key.getPublic().getEncoded());
        sig.update(sharedSecret);
        writeObject(sig.sign());
    }

View Full Code Here

        try {
            String serverKeyAlgorithm = readUTF();
            PublicKey spk = KeyFactory.getInstance(serverKeyAlgorithm).generatePublic(readKey());


            // verify the identity of the server
            Signature sig = Signature.getInstance("SHA1with"+serverKeyAlgorithm);
            sig.initVerify(spk);
            sig.update(spk.getEncoded());
            sig.update(sharedSecret);
            sig.verify((byte[]) readObject());


            return spk;
        } catch (ClassNotFoundException e) {
            throw new Error(e); // impossible
        }

View Full Code Here

    
    public byte[] sign(byte[]... data) {
        byte[] result = null;
        try {
            while(true) {
                Signature sig = Signature.getInstance(curve.defaultHashAlgorithm, curve.sigProvider);
                sig.initSign(key.getPrivate());
          for(byte[] d: data)
            sig.update(d);
                result = sig.sign();
                // It's a DER encoded signature, most sigs will fit in N bytes
                // If it doesn't let's re-sign.
                if(result.length <= curve.maxSigSize)
                  break;
                else

View Full Code Here

    public static boolean verify(Curves curve, ECPublicKey key, byte[] signature, int sigoffset, int siglen,  byte[]... data) {
        if(key == null || curve == null || signature == null || data == null)
            return false;
        boolean result = false;
        try {
            Signature sig = Signature.getInstance(curve.defaultHashAlgorithm, curve.sigProvider);
            sig.initVerify(key);
      for(byte[] d: data)
        sig.update(d);
            result = sig.verify(signature, sigoffset, siglen);
        } catch (NoSuchAlgorithmException e) {
            Logger.error(ECDSA.class, "NoSuchAlgorithmException : "+e.getMessage(),e);
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            Logger.error(ECDSA.class, "InvalidKeyException : "+e.getMessage(),e);

View Full Code Here

                log.log(Level.FINE, "user certificate is not trusted", ex);
                return false;
            }


            try {
                Signature s = Signature.getInstance(algorithm);
                s.initVerify(chain[0]);
                s.update(message);
                return s.verify(signature);
            } catch (Exception ex) {
                LogRecord lr = new LogRecord(Level.WARNING, "Error while verifing message of user {0}");
                lr.setParameters(new Object[]{username});
                lr.setThrown(ex);
                log.log(lr);

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");
        normalSig.initSign(privKey);
        normalSig.update(sampleMessage);
        byte[] normalResult = normalSig.sign();


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


        Signature rawSig = Signature.getInstance("RSA", "BC");
        rawSig.initSign(privKey);
        rawSig.update(digInfo);
        byte[] rawResult = rawSig.sign();


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


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


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

View Full Code Here

        KeyFactory fact = KeyFactory.getInstance("RSA", "BC");


        PrivateKey  privKey = fact.generatePrivate(privKeySpec);
        PublicKey   pubKey = fact.generatePublic(pubKeySpec);


        Signature s = Signature.getInstance("SHA1withRSA/PSS", "BC");


        s.initSign(privKey, new FixedRandom(slt1a));
        s.update(msg1a);
        byte[] sig = s.sign();


        if (!arrayEquals(sig1a, sig))
        {
           fail("PSS Sign test expected " + new String(Hex.encode(sig1a)) + " got " + new String(Hex.encode(sig)));
        }


        s = Signature.getInstance("SHA1withRSAandMGF1", "BC");
        
        s.initVerify(pubKey);
        s.update(msg1a);
        if (!s.verify(sig1a))
        {
            fail("SHA1 signature verification failed");
        }


        s = Signature.getInstance("SHA1withRSAandMGF1", "BC");
        
        s.setParameter(PSSParameterSpec.DEFAULT);
        
        s.initVerify(pubKey);
        s.update(msg1a);
        if (!s.verify(sig1a))
        {
            fail("SHA1 signature verification with default parameters failed");
        }
        
        AlgorithmParameters pss = s.getParameters();
        if (!arrayEquals(pss.getEncoded(), new byte[] { 0x30, 0x00 }))
        {
            fail("failed default encoding test.");
        }
        
        s = Signature.getInstance("SHA256withRSA/PSS", "BC");


        s.initSign(privKey, new FixedRandom(slt1a));
        s.update(msg1a);
        sig = s.sign();


        pss = s.getParameters();
        
        if (!arrayEquals(sig1b, sig))
        {
            fail("PSS Sign test expected " + new String(Hex.encode(sig1b)) + " got " + new String(Hex.encode(sig)));
        }


        s = Signature.getInstance("SHA256withRSAandMGF1", "BC");
        
        s.setParameter(pss.getParameterSpec(PSSParameterSpec.class));
        
        s.initVerify(pubKey);
        s.update(msg1a);
        if (!s.verify(sig1b))
        {
            fail("SHA256 signature verification failed");
        }


        //
        // 512 test -with zero salt length
        //
        s = Signature.getInstance("SHA512withRSAandMGF1", "BC");
        
        s.setParameter(new PSSParameterSpec("SHA-512", "MGF1", new MGF1ParameterSpec("SHA-512"), 0, 1));
        s.initSign(privKey);


        s.update(msg1a);
        sig = s.sign();


        pss = s.getParameters();
        
        if (!arrayEquals(sig1c, sig))
        {
            fail("PSS Sign test expected " + new String(Hex.encode(sig1c)) + " got " + new String(Hex.encode(sig)));
        }


        s = Signature.getInstance("SHA512withRSAandMGF1", "BC");
        
        s.setParameter(pss.getParameterSpec(PSSParameterSpec.class));
        
        s.initVerify(pubKey);
        s.update(msg1a);
        if (!s.verify(sig1c))
        {
            fail("SHA512 signature verification failed");
        }


        SecureRandom random = new SecureRandom();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.security.Signature$CipherAdapter

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.