Examples of java.security.SignedObject

java.security.SignedObject
SignedObject is a class for the purpose of creating authentic runtime objects whose integrity cannot be compromised without being detected.
More specifically, a SignedObject contains another Serializable object, the (to-be-)signed object and its signature.
The signed object is a "deep copy" (in serialized form) of an original object. Once the copy is made, further manipulation of the original object has no side effect on the copy.
The underlying signing algorithm is designated by the Signature object passed to the constructor and the verify method. A typical usage for signing is the following:
```
 Signature signingEngine = Signature.getInstance(algorithm, provider); SignedObject so = new SignedObject(myobject, signingKey, signingEngine); 
```
A typical usage for verification is the following (having received SignedObject so):
```
 Signature verificationEngine = Signature.getInstance(algorithm, provider); if (so.verify(publickey, verificationEngine)) try { Object myobj = so.getObject(); } catch (java.lang.ClassNotFoundException e) {}; 
```
Several points are worth noting. First, there is no need to initialize the signing or verification engine, as it will be re-initialized inside the constructor and the verify method. Secondly, for verification to succeed, the specified public key must be the public key corresponding to the private key used to generate the SignedObject.
More importantly, for flexibility reasons, the constructor and verify method allow for customized signature engines, which can implement signature algorithms that are not installed formally as part of a crypto provider. However, it is crucial that the programmer writing the verifier code be aware what Signature engine is being used, as its own implementation of the verify method is invoked to verify a signature. In other words, a malicious Signature may choose to always return true on verification in an attempt to bypass a security check.
The signature algorithm can be, among others, the NIST standard DSA, using DSA and SHA-1. The algorithm is specified using the same convention as that for signatures. The DSA algorithm using the SHA-1 message digest algorithm can be specified, for example, as "SHA/DSA" or "SHA-1/DSA" (they are equivalent). In the case of RSA, there are multiple choices for the message digest algorithm, so the signing algorithm could be specified as, for example, "MD2/RSA", "MD5/RSA" or "SHA-1/RSA". The algorithm name must be specified, as there is no default.
The name of the Cryptography Package Provider is designated also by the Signature parameter to the constructor and the verify method. If the provider is not specified, the default provider is used. Each installation can be configured to use a particular provider as default.
Potential applications of SignedObject include:
- It can be used internally to any Java runtime as an unforgeable authorization token -- one that can be passed around without the fear that the token can be maliciously modified without being detected.
- It can be used to sign and serialize data/object for storage outside the Java runtime (e.g., storing critical access control data on disk).
- Nested SignedObjects can be used to construct a logical sequence of signatures, resembling a chain of authorization and delegation.
@see Signature @version 1.44, 11/17/05 @author Li Gong

    }
      prop = new Properties();
      prop.put("aaa", "bbb");
      Object o = null;
      try {
        o = new SignedObject(prop, tkp.getPrivate(), sig);
      } catch (IOException e) {
             fail(e.toString());  
      } catch (SignatureException e) {   
             fail(e.toString());  
      } catch (InvalidKeyException e) {

View Full Code Here

    }
       return new Object[] { o };
    }


    public void assertDeserialized(Serializable oref, Serializable otest) {
      SignedObject ref = (SignedObject) oref;
      SignedObject test = (SignedObject) otest;


      assertEquals(test.getAlgorithm(), ref.getAlgorithm());
 
        try {
            assertEquals(test.getObject(), prop);        
        } catch (ClassNotFoundException e) {
             fail(e.toString());  
        } catch (IOException e) {
             fail(e.toString());  
        }
        try {
          if (!test.verify(tkp.getPublic(), sig)) {
              fail("verify() failed");
            }  
        } catch (SignatureException e) {
          fail(e.toString());        
        } catch (InvalidKeyException e) {

View Full Code Here

            return;
        }
        prop = new Properties();
        prop.put("aaa", "bbb");


        SignedObject so = new SignedObject(prop, tkp.getPrivate(), sig);


        assertEquals("SHA1withDSA", so.getAlgorithm());
        assertEquals(prop, so.getObject());


        assertTrue("verify() failed", so.verify(tkp.getPublic(), sig));


        assertNotNull("signature is null", so.getSignature());
    }

View Full Code Here

    }
      prop = new Properties();
      prop.put("aaa", "bbb");
      Object o = null;
      try {
        o = new SignedObject(prop, tkp.getPrivate(), sig);
      } catch (IOException e) {
             fail(e.toString());  
      } catch (SignatureException e) {   
             fail(e.toString());  
      } catch (InvalidKeyException e) {

View Full Code Here

    }
       return new Object[] { o };
    }


    public void assertDeserialized(Serializable oref, Serializable otest) {
      SignedObject ref = (SignedObject) oref;
      SignedObject test = (SignedObject) otest;


      assertEquals(test.getAlgorithm(), ref.getAlgorithm());
 
        try {
            assertEquals(test.getObject(), prop);        
        } catch (ClassNotFoundException e) {
             fail(e.toString());  
        } catch (IOException e) {
             fail(e.toString());  
        }
        try {
          if (!test.verify(tkp.getPublic(), sig)) {
              fail("verify() failed");
            }  
        } catch (SignatureException e) {
          fail(e.toString());        
        } catch (InvalidKeyException e) {

View Full Code Here


        String SIGALG = "SHA1withRSA";
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
        KeyPair kp = kpg.generateKeyPair();


        SignedObject so1 = new SignedObject("Hello", kp.getPrivate(),
                Signature.getInstance(SIGALG));


        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(so1);
        out.close();


        byte[] data = byteOut.toByteArray();


        SignedObject so2 = (SignedObject)new ObjectInputStream(
                new ByteArrayInputStream(data)).readObject();


        if (!so2.getObject().equals("Hello")) {
            throw new Exception("Content changed");
        }
        if (!so2.getAlgorithm().equals(SIGALG)) {
            throw new Exception("Signature algorithm unknown");
        }
        if (!so2.verify(kp.getPublic(), Signature.getInstance(SIGALG))) {
            throw new Exception("Not verified");
        }
    }

View Full Code Here

TOP

Related Classes of java.security.SignedObject

ch.ethz.prose.SignedAspect

Correctness

org.apache.harmony.security.tests.java.security.serialization.SignedObjectTest

org.apache.harmony.security.tests.java.security.SignedObjectTest

java.io.ObjectInput

java.io.ObjectOutputStream

java.io.ObjectInputStream

java.io.ByteArrayOutputStream

java.io.ByteArrayInputStream

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.