5 Oracle CMS

5.3.2.1.1 Constructing a CMS Object

Perform the following steps to construct a CMS object:

1. Create the object of the specified content type.

2. Initialize the object.

3. Call the output(..) method to write the object encoding.

If you are reading in an existing CMSContentInfo, but you do not know the concrete type in advance, use inputInstance(). To create a new object, use one of the constructors of the concrete subclass with which you are working. To read in one of a known concrete type, use the no-args constructor and then invoke the input() method.

5.3.2.1.2 Reading a CMS Object

Perform the following steps to read an object:

1. Call CMSContentInfo.inputInstance(..) to read in the object.

2. Call getContentType() to determine its content type.

3. You can now invoke the content type-specific operations.

5.3.2.4.1 Constructing a CMS Digested-data Object

Take the following steps to create a CMS digested-data object.

1. Create an instance of CMSDigestedDataContentInfo using the constructor that takes the object to be digested and the digest algorithm identifier. For example, if contentInfo is a CMSDataContentInfo object and MD5 is the digest algorithm:

   CMSDigestedDataContentInfo dig =
       new CMSDigestedDataContentInfo(contentInfo, CMS.md5);
   
   

2. Write the CMS digested-data object to a file named data.p7m.

   dig.output(new FileOutputStream("data.p7m"));
   
   

5.3.2.4.2 Reading a CMS Digested-data Object

The steps you need to read a CMS digested-data object depend on whether you know the object's content type.

1. Open a connection to the data.p7m file using FileInputStream.

   If you know that the object stored in the file is of content type id-digestedData:

   CMSDigestedDataContentInfo digdata =
       new CMSDigestedDataContentInfo(new FileInputStream("data.p7m"));
   
   

   However, if you do not know the content type in advance:

   CMSContentInfo cmsdata =
       CMSContentInfo.inputInstance(new FileInputStream("data.p7m"));
   if (cmsdata instanceof CMSDigestedDataContentInfo)
   {
       CMSDigestedDataContentInfo digdata =
           (CMSDigestedDataContentInfo) cmsdata;
       // .....
   }
   
   

2. To access the information stored in the CMS digested-data object:

   int version = digdata.getVersion().intValue();
   AlgorithmIdentifier digestAlgID = digdata.getDigestAlgID();
   byte[] digestValue = digdata.getDigest();
   CMSContentInfo digContentInfo = digData.getEnclosed()
   if (digData.getEnclosedContentType().equals(CMS.id_data))
       CMSDataContentInfo contentInfo = (CMSDataContentInfo)digContentInfo;
   
   

3. To verify the integrity of the protected data, verify the digest:

   digData.verify();
   
   

5.3.2.4.3 Detached digested-data Objects

When working with a detached object, the object that is digested is not a part of the resulting CMS digested-data structure. To generate a detached object, call the writeDetached (true | false) method. For example:

dig.writeDetached(true);

While you can read in a detached CMS digested-data object as shown earlier, the digest verification will fail because the original object that was digested is not present. To resolve this, call the setEnclosed (CMScontentInfo) method to set the digestedContent:

digdata.setEnclosed(CMScontentInfo object);

followed by digest verification:

digdata.verify();

5.3.2.5.1 Constructing a CMS Signed-data Object

Follow these steps to create a CMS signed-data object:

1. Create an instance of CMSDigestedDataContentInfo. For example, to create the CMSDigestedDataContentInfo object contentInfo that is to be signed:

   CMSDigestedDataContentInfo sig =
       new CMSSignedDataContentInfo(contentInfo);
   
   

2. Add signatures:

   X509 signerCert = new X509(new FileInputStream("name"));
   PrivateKey signerKey =
       CryptoUtils.inputPrivateKey(new FileInputStream("name"));
   
   

   1. To add a signature using the IssuerAndSerialNo as the SignerIdentifier, MD5 digests and RSA Signature Algorithm:

      sig.addSignature(null, signerKey, signerCert, CMS.md5,
          CMS.rsaEncryption, null);
      
      

   2. To add a signature using the 64 bit SubjectKeyIdentifier as the SignerIdentifier, SHA-1 digests and DSS Signature Algorithm:

      sig.addSignature(null, signerKey, signerCert, CMS.sha_1,
          CMS.dsaWithSHA, null, true);
      
      

   3. To add a signature using the 160 bit SubjectKeyIdentifier as the SignerIdentifier, SHA-1 digests and RSA Signature Algorithm:

      sig.addSignature(null, signerKey, signerCert, CMS.sha_1,
          CMS.rsaEncryption, null, false);
      
      

3. Add any Certificates and CRLs:

   sig.addCertificate (....)
   sig.addCRL (...)
   
   

4. Write the CMS signed-data object to a file, for example data.p7m:

   sig.output(new FileOutputStream("data.p7m"));
   
   

5.3.2.5.2 Reading a CMS Signed-data Object

The steps you need to read a CMS signed-data object depend on whether you know the object's content type.

1. Open a connection to the data.p7m file using FileInputStream.

   If you know that the object stored in the file is of content type id-signedData:

   CMSSignedDataContentInfo sigdata =
       new CMSSignedDataContentInfo(new FileInputStream("data.p7m"));
   
   

   However, if you do not know the content type in advance:

   CMSContentInfo cmsdata =
       CMSContentInfo.inputInstance(new FileInputStream("data.p7m"));
   if (cmsdata instanceof CMSSignedDataContentInfo)
   {
       CMSSignedDataContentInfo sigdata =
           (CMSSignedDataContentInfo) cmsdata;
       // .....
   }
   
   

2. Access the information stored in the CMS signed-data object:

   int version = sigdata.getVersion().intValue();
   CMSContentInfo sigContentInfo = sigData.getEnclosed()
   Vector certs = sigdata.getCertificates();
   Vector crls = sigData.getCRLs();
   Enumeration e = sigData.signers();
   if (digData.getEnclosedContentType().equals(CMS.id_data))
       CMSDataContentInfo contentInfo = (CMSDataContentInfo)digContentInfo;
   
   

3. Verify the signature using the signer's public key certificate:

   sigData.verify(signerCert);
   
   

4. To get more information about the signer:

   CMSSignerInfo sigInfo = sigdata.getSignerInfo(signerCert);
   byte[] signatureValue = sigInfo.getEncryptedDigest();
   AlgorithmIdentifier digest = sigInfo.getDigestAlgID();
   AlgorithmIdentifier signature = sigInfo.getDigestEncryptionAlgID();
   AttributeSet signedAttributes = sigInfo.getAuthenticatedAttributes();
   AttributeSet unsignedAttributes = sigInfo.getUnauthenticatedAttributes();
   
   

5.3.2.5.3 External Signatures (Detached Objects)

For a detached object, the signed object is not part of the resulting CMS signed-data structure. To generate a detached object, call the writeExternalSignature() method:

sig.writeExternalSignature(true);

While you can read in a detached CMS signed-data object as shown in "Reading a CMS Signed-data Object", the signature verification will fail because the original object that was signed is not present. Call the setEnclosed (..) method to set the signed content:

sigdata.setEnclosed(contentInfo);

followed by signature verification:

sigdata.verify(signerCert);

5.3.2.5.4 Certificates/CRL-Only Objects

These are essentially CMSSignedDataContentInfo objects with attached certificates, or CRLs, or both, but without any signatures. To generate a Certificate/CRL-only object:

CMSSignedDataContentInfo sigdata = 
    new CMSSignedDataContentInfo(new CMSDataContentInfo(new byte[0]));
sigData.addCertificate (...);
sigData.addCRL( ...);
sigData.output(..);

You can read in a Certificate/CRL-only signed-data object as shown in "Reading a CMS Signed-data Object".

5.3.2.6.1 Constructing a CMS Encrypted-data Object

To create an encrypted-data object:

1. Create an instance of CMSEncrytedDataContentInfo. For example, if contentInfo is a CMSDataContentInfo object and the cipher is Triple-DES in CBC mode:

   SymmetricKey contentEncryptionKey =
       SymmetricKeyGenerator.getInstance(CMS.des_ede3_cbc).generateKey();
   CMSEncrytedDataContentInfo enc =
       new CMSEncrytedDataContentInfo(contentInfo, contentEncryptionKey,
           CMS.des_ede3_cbc);
   
   

2. Write the encrypted-data object to a file, say data.p7m:

   enc.output(new FileOutputStream("data.p7m"));
   
   

5.3.2.6.2 Reading a CMS Encrypted-data Object

The steps you need to read an encrypted-data object depend on whether you know the object's content type.

1. Open a connection to the data.p7m file using FileInputStream.

   If you know that the object stored in the file data.p7m is of content type id-encryptedData:

   CMSEncrytedDataContentInfo encdata =
       new CMSEncrytedDataContentInfo(new FileInputStream("data.p7m"));
   
   

   However, if you do not know the content type in advance:

   CMSContentInfo cmsdata =
       CMSContentInfo.inputInstance(new FileInputStream("data.p7m"));
   if (cmsdata instanceof CMSEncrytedDataContentInfo)
   {
       CMSEncrytedDataContentInfo encdata =
           (CMSEncrytedDataContentInfo) cmsdata;
       // .....
   }
   
   

2. To access the information stored in the CMS encrypted-data object:

   int version = encdata.getVersion().intValue();
   AlgorithmIdentifier encAlgID = encdata.getContentEncryptionAlgID();
   byte[] encValue = encdata.getEncryptedContent();
   CMSContentInfo encContentInfo =
       encdata.getEnclosed(ContentEncryptionKey);  //Decrypt the Content
   if (encData.getEnclosedContentType().equals(CMS.id_data))
      CMSDataContentInfo contentInfo = (CMSDataContentInfo)encContentInfo;
   
   

5.3.2.6.3 Detached encrypted-data CMS Objects

If it is a detached object, the encrypted object is not a part of the resulting CMS encrypted-data structure. To generate a detached object, call the writeDetached (..) method:

enc.writeDetached(true);

While you can read in a detached CMS encrypted-data object as shown in "Reading a CMS Encrypted-data Object", the content decryption will fail because the original object that was encrypted is not present. Call the setEncryptedContent (..) method to set the encryptedContent:

encData.setEncryptedContent(enc.getEncryptedContent());

followed by content decryption:

encdata.getEnclosed(ContentEncryptionKey);

5.3.2.7.1 Constructing a CMS Enveloped-data Object

To create an enveloped-data object:

1. Create an instance of CMSEnvelopedDataContentInfo. For example, if contentInfo is a CMSDataContentInfo object and the cipher is Triple-DES in CBC mode:

   CMSEnvelopedDataContentInfo env = 
       new CMSEnvelopedDataContentInfo(contentInfo, CMS.des_ede3_cbc);
   
   
   

2. Add recipients, keeping in mind the recipient's key management technique.

   • If the recipient uses the key encryption (wrap) key management mechanism:

     env.addRecipient(keyEncryptionAlgID, keyEncryptionKey,
         keyIdentifier, keyDate, otherKeyAttribute);
     
     

   • If the recipient key exchange mechanism was specified using a CMSRecipientInfoSpec object:

     env.addRecipient(ris)
     
     

   • If the recipient uses the key transport (IssuerAndSerialNo recipient identifier) key management mechanism:

     env.addRecipient(recipientCert, CMS.rsaEncryption);
     
     

   • If the recipient uses the key transport (64-bit SubjectKeyIdentifier recipient identifier) key management mechanism:

     env.addRecipient(recipientCert, CMS.rsaEncryption, true)
     
     

   • If the recipient uses the key transport (160-bit SubjectKeyIdentifier recipient identifier) key management mechanism:

     env.addRecipient(recipientCert, CMS.rsaEncryption, false)
     
     

3. Set any optional arguments:

   env.setAuthenticatedAttributes(authenticatedAttributes, CMS.md5);
   env.setOriginatorInfo(originatorInfo);
   env.setUnauthenticatedAttributes(unauthenticatedAttributes);
   
   

4. Write the CMS enveloped-data object to a file, say data.p7m:

   enc.output(new FileOutputStream("data.p7m"));
   
   

5.3.2.7.2 Reading a CMS Enveloped-data Object

The steps you need to read the object depend on whether you know the object's content type.

1. Open a connection to the data.p7m file using FileInputStream. If you know that the object stored in the file is of content type id-envelopedData:

   CMSEnvelopedDataContentInfo envdata =
       new CMSEnvelopedDataContentInfo(new FileInputStream("data.p7m"));
   
   

   However, if you do not know the content type in advance:

   CMSContentInfo cmsdata =
       CMSContentInfo.inputInstance(new FileInputStream("data.p7m"));
   if (cmsdata instanceof CMSEnvelopedDataContentInfo)
   {
       CMSEnvelopedDataContentInfo envdata =
           (CMSEnvelopedDataContentInfo) cmsdata;
       // 
       .....
   }
   
   

2. To access the information stored in the enveloped-data object:

   int version = envdata.getVersion().intValue();
   AlgorithmIdentifier encAlgID = envdata.getContentEncryptionAlgID();
   ASN1ObjectID contentType = env.getEnclosedContentType();
   byte[] encryptedContent = env.getEncryptedContent();
   OriginatorInfo origInfo = env.getOriginatorInfo();
   AttributeSet unprotected = env.getUnprotectedAttribs();
   
   

3. Decrypt the content depending on the recipient information:

   CMSContentInfo envContentInfo =
       env.getEnclosed(privateKey, recipientCert);
   
   

   or

   CMSContentInfo envContentInfo =
       env.getEnclosed(symmetricKey, keyIdentifier);
   
   

   or

   CMSContentInfo envContentInfo =
       env.getEnclosed(symmetricKey, keyIdentifier, keyDate)
   if (envContentInfo instanceof CMSDataContentInfo)
   {
       CMSDataContentInfo contentInfo = (CMSDataContentInfo) envContentInfo;
       // ...
   }
   
   

5.3.2.7.3 Key Transport Key Exchange Mechanism

This mechanism supports the use of either IssuerAndSerialNo or SubjectKeyIdentifier as the recipient identifier.

5.3.2.7.4 Key Agreement Key Exchange Mechanism

This mechanism is not currently supported.

5.3.2.7.5 Key Encryption (Wrap) Key Exchange Mechanism

Oracle CMS supports CMS3DESWrap and CMSRC2Wrap algorithms. Mixed mode wrapping is not supported; for example, 3DES keys cannot be RC2-wrapped.

5.3.2.7.6 Detached Enveloped-data CMS Object

If working with a detached object, note that the enveloped object is not part of the resulting CMS enveloped-data structure. Call the writeDetached (..) method to generate a detached object:

env.writeDetached(true);

While you can read in a detached enveloped-data object as shown in "Reading a CMS Enveloped-data Object", the content decryption will fail because the original, enveloped object is not present. Call the setEnclosed (..) method to set the enveloped content:

envdata.setEnclosed(env.getEncryptedContent());

followed by content decryption:

envdata.getEnclosed(............);

5.3.2.8.1 Constructing a CMS Authenticated-data Object

Take the following steps to create an authenticated-data object:

1. Create an instance of CMSAuthenticatedDataContentInfo. For example, if contentInfo is a CMSDataContentInfo object, Triple-DES HMAC key and HMAC with SHA-1 MAC algorithm:

   SymmetricKey contentEncryptionKey =
       SymmetricKeyGenerator.getInstance(CMS.des_ede3_cbc).generateKey();
   CMSAuthenticatedDataContentInfo auth = 
       new CMSAuthenticatedDataContentInfo(contentInfo, 
   contentEncryptionKey, CMS.hmac_SHA_1);
   
   

2. Add recipients, keeping in mind the recipient's key management technique.

   • If the recipient uses the key encryption (wrap) key management mechanism:

     auth.addRecipient(keyEncryptionAlgID, keyEncryptionKey, keyIdentifier,
         keyDate, otherKeyAttribute);
     
     

   • If the recipient key exchange mechanism was specified using a CMSRecipientInfoSpec object:

     auth.addRecipient(ris)
     
     

   • If the recipient uses the key transport (IssuerAndSerialNo recipient identifier) key management mechanism:

     auth.addRecipient(recipientCert, CMS.rsaEncryption);
     
     

   • If the recipient uses the key transport (64-bit SubjectKeyIdentifier recipient identifier) key management mechanism:

     auth.addRecipient(recipientCert, CMS.rsaEncryption, true)
     
     

   • If the recipient uses the key transport (160-bit SubjectKeyIdentifier recipient identifier) key management mechanism:

     auth.addRecipient(recipientCert, CMS.rsaEncryption, false)
     
     

3. Set any optional arguments:

   auth.setAuthenticatedAttributes(authenticatedAttributes, CMS.md5);
   auth.setOriginatorInfo(originatorInfo);
   auth.setUnauthenticatedAttributes(unauthenticatedAttributes);
   
   

4. Write the CMS authenticated-data object to a file, say data.p7m:

   auth.output(new FileOutputStream("data.p7m"));
   
   

5.3.2.8.2 Reading a CMS Authenticated-data Object

The steps you need to read the object depend on whether you know the object's content type:

1. Open a connection to the data.p7m file using FileInputStream. If you know that the object stored in the file is of content type id-ct-authData:

   CMSAuthenticatedDataContentInfo authdata =
       new CMSAuthenticatedDataContentInfo(new FileInputStream("data.p7m"));
   
   

   However, if you do not know the content type in advance:

   CMSContentInfo cmsdata =
       CMSContentInfo.inputInstance(new FileInputStream("data.p7m"));
   if (cmsdata instanceof  CMSAuthenticatedDataContentInfo)
   {
   CMSAuthenticatedDataContentInfo authdata = 
                                (CMSAuthenticatedDataContentInfo) cmsdata;
      // .....
   }
   
   

2. To access the information stored in the CMS authenticated-data object:

   int version = authdata.getVersion().intValue();
   AlgorithmIdentifier macAlgID = authdata.getMACAlgID();
   byte[] macValue = authdata.getMAC();
   CMSContentInfo authContentInfo = authdata.getEnclosed();
   if (authData.getEnclosedContentType().equals(CMS.id_data))
       CMSDataContentInfo contentInfo = (CMSDataContentInfo)authContentInfo;
   
   

3. Verify the MAC depending on the recipient information:

   authdata.verifyMAC(recipientPrivateKey, recipientCert);
   
   

   or

   authdata.verifyMAC(symmetricKey, keyIdentifier)
   
   

   or

   authdata.verifyMAC(symmetricKey, keyIdentifier, keyDate)
   
   

   or

   authdata.verifyMAC(symmetricKey, keyIdentifier, keyDate,
       otherKeyAttribute)
   
   

5.3.2.8.3 Detached Authenticated-data CMS Objects

While you can read in a detached authenticated-data object as shown earlier, the MAC verification will fail because the original object that was authenticated is not present. To resolve this, call the setEnclosed (..) method to set the authenticated content:

authdata.setEnclosed(contentInfo);

followed by MAC verification using the appropriate key exchange mechanism:

authdata.verifyMAC(...)

5.3.2.9.1 Reading a Nested (Wrapped) CMS Object

The approach to reading a nested object depends on whether you know the outermost content type in advance.

If you do not know the outermost content type in advance, call the static method:

CMSContentInfo.inputInstance( ... )

If you do know the outermost content type in advance, call the appropriate constructor:

new CMS***DataContentInfo( .... )

Then, recursively call the getEnclosed(..) method to extract the next inner object.

5.3.3.3.1 CMS id-data Object

The getData() method returns the data which can then be written to a CMS***OutputStream or CMS***OutputConnector.

5.3.3.3.2 CMS id-ct-receipt Object

The getReceiptData() method returns the encoded receipt which can then be written to a CMS***OutputStream or CMS***OutputConnector.

To read ESSReceipt data from the input stream:

byte[] rcptData = in.read(...);
ESSReceipt er = new ESSReceipt();
er.inputContent(rcptData);

5.3.3.3.3 CMS id-digestedData Object

You will not be able to verify the digest of a detached digested-data object. Setting the boolean parameter writeEContentInfo in the CMSSignedDataOutputStream constructor to false enables you to create a detached digested-data object.

5.3.3.3.4 CMS id-signedData Object

You will not be able to verify the signature of a detached signed-data object.

The CMSSignerInfoSpec class stores signer-specific information. For every signature you want to add, you will need to create a corresponding CMSSignerInfoSpec object which is then passed to the constructor.

Setting the boolean parameter createExternalSignatures in the CMSEncryptedDataOutputStream constructor to true enables you to create a detached signed-data object or external signatures.

To create a Certificate/CRL only object, do not pass any signer information to the CMSDigestedDataOutputStream constructor.

5.3.3.3.5 CMS id-encryptedData Objects

Setting the boolean parameter writeEncryptedOutput in the CMSDigestedDataOutputStream constructor to false enables you to create a detached encrypted-data object.

5.3.3.3.6 CMS id-envelopedData Objects

The CMSRecipientInfoSpec class stores recipient-specific information. For every recipient you want to add, you will need to create a corresponding CMSRecipientInfoSpec object which is then passed to the constructor.

Setting the boolean parameter writeContent in the CMSEnvelopedDataOutputStream constructor to false enables you to create a detached enveloped-data object.

Key Transport Key Exchange Mechanism

Use the CMSKeyTransRecipientInfoSpec class to store recipient information that uses the key transport key management mechanism.

Key Agreement Key Exchange Mechanism

This mechanism is not supported at this time.

Key Encryption (wrap) Key Exchange Mechanism

Use the CMSKEKRecipientInfoSpec class to store recipient information that uses the key wrap key management mechanism.

5.3.3.3.7 CMS id-ct-authData Objects

You will not be able to verify the MAC of a detached authenticated-data object.

Setting the boolean parameter detachEncapContent in the CMSAuthenticatedDataOutputStream constructor to true enables you to create a detached authenticated-data object.