// Copyright (C) 2002 IAIK
// https://sic.tech/
//
// Copyright (C) 2003 - 2025 Stiftung Secure Information and 
//                           Communication Technologies SIC
// https://sic.tech/
//
// All rights reserved.
//
// This source is provided for inspection purposes and recompilation only,
// unless specified differently in a contract with IAIK. This source has to
// be kept in strict confidence and must not be disclosed to any third party
// under any circumstances. Redistribution in source and binary forms, with
// or without modification, are <not> permitted in any case!
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//
// $Header: /IAIK-CMS/current/src/demo/cms/ecc/EdDHAuthEnvelopedDataDemo.java 5     12.02.25 17:58 Dbratko $
// $Revision: 5 $
//


package demo.cms.ecc;

import iaik.asn1.CodingException;
import iaik.asn1.ObjectID;
import iaik.asn1.structures.AlgorithmID;
import iaik.asn1.structures.Attribute;
import iaik.cms.AuthEnvelopedData;
import iaik.cms.AuthEnvelopedDataOutputStream;
import iaik.cms.AuthEnvelopedDataStream;
import iaik.cms.CMSAlgorithmID;
import iaik.cms.CMSException;
import iaik.cms.CertificateIdentifier;
import iaik.cms.ContentInfo;
import iaik.cms.ContentInfoOutputStream;
import iaik.cms.ContentInfoStream;
import iaik.cms.EncryptedContentInfo;
import iaik.cms.EncryptedContentInfoStream;
import iaik.cms.IssuerAndSerialNumber;
import iaik.cms.KeyAgreeRecipientInfo;
import iaik.cms.KeyIdentifier;
import iaik.cms.RecipientInfo;
import iaik.cms.RecipientKeyIdentifier;
import iaik.cms.attributes.CMSContentType;
import iaik.security.random.SecRandom;
import iaik.utils.Util;
import iaik.x509.X509Certificate;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.SecureRandom;

import javax.crypto.SecretKey;

import demo.DemoUtil;
import demo.cms.ecc.keystore.CMSEccKeyStore;


/**
 * Demonstrates the usage of class {@link iaik.cms.AuthEnvelopedDataStream},
 * {@link iaik.cms.AuthEnvelopedData} and {@link iaik.cms.AuthEnvelopedDataOutputStream} 
 * for authenticated encrypting data with the CMS content type AuthEnvelopedData using the 
 * Elliptic Curve Diffie-Hellman (ECDH) key agreement algorithm with curve25519 and
 * curve448 according to <a href = "http://www.ietf.org/rfc/rfc5083.txt" target="_blank">RFC 5083</a>
 * and <a href = "http://www.ietf.org/rfc/rfc8418.txt" target="_blank">RFC 8418</a>.
 * <p>
 * This demo uses the AES-CCM and AES-GCM authenticated encryption algorithms
 * as specified by <a href = "http://www.ietf.org/rfc/rfc5084.txt" target="_blank">RFC 5084</a>.
 * The demo creates an AuthEnvelopedData object and subsequently shows several
 * ways that may be used for decrypting the content and verifying the message
 * authentication code for some particular recipient.
 * <br>
 * Since AES-CCM and AES-GCM are not implemented by IAIK-JCE versions prior 3.17, this demo
 * at least may require IAIK-JCE 3.17 as cryptographic service provider. 
 * <p>
 * Any keys/certificates required for this demo are read from a keystore
 * file "cmsecc.keystore" located in your current working directory. If
 * the keystore file does not exist you can create it by running the
 * {@link demo.cms.ecc.keystore.SetupCMSEccKeyStore SetupCMSEccKeyStore}
 * program. 
 * <p>
 * Additionally to <code>iaik_cms.jar</code> you also must have 
 * <code>iaik_jce_(full).jar</code> (IAIK-JCE, <a href =
 * "https://sic.tech/products/core-crypto-toolkits/jca-jce/" target="_blank">
 * https://sic.tech/products/core-crypto-toolkits/jca-jce/</a>),
 * and <code>iaik_eccelarate.jar</code> (IAIK-ECCelerate<sup><small>TM</small></sup>, <a href =
 * "https://sic.tech/products/core-crypto-toolkits/eccelerate/" target="_blank">
 * https://sic.tech/products/core-crypto-toolkits/eccelerate/</a>)
 * in your classpath.
 * 
 * @see iaik.cms.AuthEnvelopedDataStream
 * @see iaik.cms.AuthEnvelopedData
 * @see iaik.cms.AuthEnvelopedDataOutputStream
 * @see iaik.cms.RecipientInfo
 * @see iaik.cms.KeyAgreeRecipientInfo
 */
public class EdDHAuthEnvelopedDataDemo {

  //certificate of x25519 user
  X509Certificate x25519User;
  // private key of x25519 user
  PrivateKey x25519User_pk;
  // certificate of x448 user 
  X509Certificate x448User;
  // private key of x448 user 
  PrivateKey x448User_pk;
  
  // secure random number generator
  SecureRandom random;

  /**
   * Setup the demo certificate chains.
   *
   * Keys and certificates are retrieved from the demo KeyStore ("cms.keystore")
   * file which has to be located in your current working directory and may be
   * created by running {@link demo.keystore.SetupCMSKeyStore
   * SetupCMSKeyStore}.
   *
   * @throws IOException if an file read error occurs
   */
  public EdDHAuthEnvelopedDataDemo() throws IOException {
    
    System.out.println();
    System.out.println("***************************************************************************************************");
    System.out.println("*                                    EdDHAuthEnvelopedDataDemo                                    *");
    System.out.println("* (shows the usage of the CMS AuthEnvelopedData type implementation with curve25519 and curve448) *");
    System.out.println("***************************************************************************************************");
    System.out.println();
    
    // get keys and certificate from the demo keystore
    x25519User = CMSEccKeyStore.getCertificateChain(CMSEccKeyStore.ECDH, CMSEccKeyStore.SZ_X25519)[0];
    x25519User_pk = CMSEccKeyStore.getPrivateKey(CMSEccKeyStore.ECDH, CMSEccKeyStore.SZ_X25519);
    x448User = CMSEccKeyStore.getCertificateChain(CMSEccKeyStore.ECDH, CMSEccKeyStore.SZ_X448)[0];
    x448User_pk = CMSEccKeyStore.getPrivateKey(CMSEccKeyStore.ECDH, CMSEccKeyStore.SZ_X448);
    random = SecRandom.getDefault();
    
  }


  /**
   * Creates a CMS <code>AuthEnvelopedDataStream</code> message.
   *
   * @param message the message to be authenticated-enveloped, as byte representation
   * @param keyEA the key encryption (key agreement) algorithm used for creating 
   *              a shared key encryption key for encrypting the secret content
   *              encryption key with it
   * @param keyWrapAlg the key wrap algorithm to be used for wrapping (encrypting) 
   *                   the content encryption key
   * @param kekLength the length of the key encryption key to be created for
   *                  encrypting the content encryption key with it     
   * @param contentAuthEncAlg the id of the content-authenticated encryption algorithm
   * 
   * @return the BER encoding of the <code>AuthEnvelopedData</code> object just created
   * 
   * @throws CMSException if the <code>AuthEnvelopedData</code> object cannot
   *                          be created
   * @throws IOException if an I/O error occurs
   */
  public byte[] createAuthEnvelopedDataStream(byte[] message, 
                                              AlgorithmID keyEA, 
                                              AlgorithmID keyWrapAlg,
                                              int kekLength, 
                                              AlgorithmID contentAuthEncAlg)
    throws CMSException, IOException {

    // we are testing the stream interface
    ByteArrayInputStream is = new ByteArrayInputStream(message);
    // create a new AuthEnvelopedData object 
    AuthEnvelopedDataStream authEnvelopedData = new AuthEnvelopedDataStream(is, contentAuthEncAlg);
    
    if (contentAuthEncAlg.equals(AlgorithmID.aes128_CCM) || 
        contentAuthEncAlg.equals(AlgorithmID.aes192_CCM) ||
        contentAuthEncAlg.equals(AlgorithmID.aes256_CCM)) {
      // for aes-ccm we need to know the data input length in advance
      authEnvelopedData.setInputLength(message.length);
    }
    
    //  create some authenticated attributes
    try {
      Attribute[] attributes = { new Attribute(new CMSContentType(ObjectID.cms_data)) };
      authEnvelopedData.setAuthenticatedAttributes(attributes);
    } catch (Exception ex) {
      throw new CMSException("Error creating attribute: " + ex.toString());   
    }

    // create the recipient infos
    RecipientInfo[] recipients = createRecipients(keyEA, keyWrapAlg, kekLength);
    // specify the recipients of the encrypted message
    authEnvelopedData.setRecipientInfos(recipients);

    // return the AuthEnvelopedDate as BER encoded byte array with block size 16
    // (just for testing; in real application we will use a proper blocksize,
    //  e.g. 2048, 4096,..)
    authEnvelopedData.setBlockSize(16);
    // wrap into ContentInfo
    ContentInfoStream contentInfo = new ContentInfoStream(authEnvelopedData);
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    contentInfo.writeTo(os);
    return os.toByteArray();
  }
  
  /**
   * Creates a CMS <code>AuthEnvelopedData</code> message using the 
   * {@link iaik.cms.AuthEnvelopedDataOutputStream AuthEnvelopedDataOutputStream}
   * class.
   *
   * @param message the message to be authenticated-enveloped, as byte representation
   * @param keyEA the key encryption (key agreement) algorithm used for creating 
   *              a shared key encryption key for encrypting the secret content
   *              encryption key with it
   * @param keyWrapAlg the key wrap algorithm to be used for wrapping (encrypting) 
   *                   the content encryption key
   * @param kekLength the length of the key encryption key to be created for
   *                  encrypting the content encryption key with it    
   * @param contentAuthEncAlg the id of the content-authenticated encryption algorithm
   * 
   * @return the BER encoding of the <code>AuthEnvelopedData</code> object just created
   * 
   * @throws CMSException if the <code>AuthEnvelopedData</code> object cannot
   *                          be created
   * @throws IOException if an I/O error occurs
   */
  public byte[] createAuthEnvelopedDataOutputStream(byte[] message, 
                                                    AlgorithmID keyEA, 
                                                    AlgorithmID keyWrapAlg,
                                                    int kekLength,
                                                    AlgorithmID contentAuthEncAlg)
    throws CMSException, IOException {

    //  a stream from which to read the data to be encrypted
    ByteArrayInputStream is = new ByteArrayInputStream(message);
    
    // the stream to which to write the AuthEnvelopedData
    ByteArrayOutputStream resultStream = new ByteArrayOutputStream();

    //  wrap AuthEnvelopedData into a ContentInfo 
    ContentInfoOutputStream contentInfoStream = 
      new ContentInfoOutputStream(ObjectID.cms_authEnvelopedData, resultStream);
   
    // create a new AuthEnvelopedData object 
    AuthEnvelopedDataOutputStream authEnvelopedData = 
        new AuthEnvelopedDataOutputStream(contentInfoStream, contentAuthEncAlg);
    
    if (contentAuthEncAlg.equals(AlgorithmID.aes128_CCM) || 
        contentAuthEncAlg.equals(AlgorithmID.aes192_CCM) ||
        contentAuthEncAlg.equals(AlgorithmID.aes256_CCM)) {
      // for aes-ccm we need to know the data input length in advance
      authEnvelopedData.setInputLength(message.length);
    }
    
    //  create some authenticated attributes
    try {
      Attribute[] attributes = { new Attribute(new CMSContentType(ObjectID.cms_data)) };
      authEnvelopedData.setAuthenticatedAttributes(attributes);
    } catch (Exception ex) {
      throw new CMSException("Error creating attribute: " + ex.toString());   
    }

    // create the recipient infos
    RecipientInfo[] recipients = createRecipients(keyEA, keyWrapAlg, kekLength);
    // specify the recipients of the encrypted message
    authEnvelopedData.setRecipientInfos(recipients);

    int blockSize = 16; // in real world we would use a block size like 2048
    //  write in the data to be encrypted
    byte[] buffer = new byte[blockSize];
    int bytesRead;
    while ((bytesRead = is.read(buffer)) != -1) {
      authEnvelopedData.write(buffer, 0, bytesRead);
    }
    
    // closing the stream finishes encryption and closes the underlying stream
    authEnvelopedData.close();
    return resultStream.toByteArray();
  }
  

  /**
   * Decrypts the encrypted content of the given <code>AuthEnvelopedData</code> object for
   * the recipient identified by its index into the recipientInfos field and verifies
   * the message authentication code.
   * <p>
   * This way of decrypting the content may be used for any type of RecipientInfo
   * (KeyTransRecipientInfo, KeyAgreeRecipientInfo, KEKRecipientInfo), but requires to
   * know at what index of the recipientInfo field the RecipientInfo for the 
   * particular recipient in mind can be found. If the recipient in mind uses
   * a RecipientInfo of type KeyAgreeRecipientInfo some processing overhead may
   * take place because a KeyAgreeRecipientInfo may contain encrypted content-encryption
   * keys for more than only one recipient; since the recipientInfoIndex only
   * specifies the RecipientInfo but not the encrypted content encryption key 
   * -- if there are more than only one -- repeated decryption runs may be
   * required as long as the decryption process completes successfully.
   *
   * @param encoding the <code>AuthEnvelopedData</code> object as DER encoded byte array
   * @param key the key to decrypt the message
   * @param recipientInfoIndex the index into the <code>RecipientInfo</code> array
   *                        to which the specified key belongs
   *
   * @return the recovered message, as byte array
   * @throws CMSException if the message cannot be recovered or MAC verification fails
   * @throws IOException if a stream read/write error occurs
   */
  public byte[] getAuthEnvelopedDataStream(byte[] encoding, Key key, int recipientInfoIndex)
    throws CMSException, IOException {

    // create the AuthEnvelopedData object from a BER encoded byte array
    ByteArrayInputStream is = new ByteArrayInputStream(encoding);
    AuthEnvelopedDataStream authEnvelopedData = new AuthEnvelopedDataStream(is);

    System.out.println("Information about the authenticated encrypted data:");
    EncryptedContentInfoStream eci = authEnvelopedData.getEncryptedContentInfo();
    System.out.println("Content type: "+eci.getContentType().getName());
    System.out.println("Content encryption algorithm: "+eci.getContentEncryptionAlgorithm().getName());

    System.out.println("\nThis message can be decrypted by the owners of the following certificates:");
    RecipientInfo[] recipients = authEnvelopedData.getRecipientInfos();
    
    // for demonstration purposes we only look one time for all recipients included:
    if (recipientInfoIndex == 0) {
      int k = 0;
      for (int i=0; i<recipients.length; i++) {
        KeyIdentifier[] recipientIDs = recipients[i].getRecipientIdentifiers();
        for (int j = 0; j < recipientIDs.length; j++) {
          System.out.println("Recipient "+(++k)+":");
          System.out.println(recipientIDs[j]);
        }   
      }
    }
    // decrypt the message for the first recipient and verify mac
    try {
      authEnvelopedData.setupCipher(key, recipientInfoIndex);
      InputStream decrypted = authEnvelopedData.getInputStream();
      ByteArrayOutputStream os = new ByteArrayOutputStream();
      Util.copyStream(decrypted, os, null);
      byte[] content = os.toByteArray();

      // get authenticated attributes
      Attribute contentTypeAttribute = authEnvelopedData.getAuthenticatedAttribute(ObjectID.contentType);
      if (contentTypeAttribute != null) {
        CMSContentType contentType = (CMSContentType)contentTypeAttribute.getAttributeValue();
        System.out.println("Authenticated content type attribute included: " + contentType.get().getName());
      }
      
      return content;
    } catch (InvalidKeyException ex) {
      throw new CMSException("Private key error: "+ex.toString());
    } catch (NoSuchAlgorithmException ex) {
      throw new CMSException("Content encryption algorithm not implemented: "+ex.toString());
    } catch (CodingException ex) {
      throw new CMSException("Error reading authenticated attributes: "+ex.toString());
    }
  }
  
  /**
   * Decrypts the encrypted content of the given <code>EnvelopedData</code> object for
   * the recipient identified by recipient identifier and verifies the message 
   * authentication code.
   * <p>
   * This way of decrypting the content may be used for any type of RecipientInfo
   * (KeyTransRecipientInfo, KeyAgreeRecipientInfo, KEKRecipientInfo). The 
   * recipient in mind is identified by its recipient identifier.
   *
   * @param encoding the <code>AuthEnvelopedData</code> object as BER encoded byte array
   * @param key the key to decrypt the message
   * @param recipientID the recipient identifier uniquely identifying the key of the
   *        recipient
   *
   * @return the recovered message, as byte array
   * @throws CMSException if the message cannot be recovered
   * @throws IOException if a stream read/write error occurs
   */
  public byte[] getAuthEnvelopedDataStream(byte[] encoding, Key key, KeyIdentifier recipientID)
    throws CMSException, IOException {

    // create the AuthEnvelopedData object from a DER encoded byte array
    ByteArrayInputStream is = new ByteArrayInputStream(encoding);
    AuthEnvelopedDataStream authEnvelopedData = new AuthEnvelopedDataStream(is);

    System.out.println("Information about the encrypted data:");
    EncryptedContentInfoStream eci = authEnvelopedData.getEncryptedContentInfo();
    System.out.println("Content type: "+eci.getContentType().getName());
    System.out.println("Content encryption algorithm: "+eci.getContentEncryptionAlgorithm().getName());
    
    // get the right RecipientInfo
    System.out.println("\nSearch for RecipientInfo:");
    RecipientInfo recipient = authEnvelopedData.getRecipientInfo(recipientID);
    if (recipient != null) {
      System.out.println("RecipientInfo: " + recipient);   
    } else {
      throw new CMSException("No recipient with ID: " + recipientID);
    }    
    // decrypt the content encryption key and the content; verify mac
    try {
      System.out.println("Decrypt encrypted content encryption key...");
      SecretKey cek = recipient.decryptKey(key, recipientID);
      System.out.println("Decrypt content with decrypted content encryption key...");
      authEnvelopedData.setupCipher(cek);
      InputStream decrypted = authEnvelopedData.getInputStream();
      ByteArrayOutputStream os = new ByteArrayOutputStream();
      Util.copyStream(decrypted, os, null);
      byte[] content = os.toByteArray();

      // get authenticated attributes
      Attribute contentTypeAttribute = authEnvelopedData.getAuthenticatedAttribute(ObjectID.contentType);
      if (contentTypeAttribute != null) {
        CMSContentType contentType = (CMSContentType)contentTypeAttribute.getAttributeValue();
        System.out.println("Authenticated content type attribute included: " + contentType.get().getName());
      }
      
      return content;
    } catch (InvalidKeyException ex) {
      throw new CMSException("Private key error: "+ex.toString());
    } catch (NoSuchAlgorithmException ex) {
      throw new CMSException("Content encryption algorithm not implemented: "+ex.toString());
    } catch (CodingException ex) {
      throw new CMSException("Error reading authenticated attributes: "+ex.toString());
    }
  }
  
  /**
   * Decrypts the encrypted content of the given <code>AuthEnvelopedData</code> object for
   * the recipient identified by its recipient certificate and verifies the message 
   * authentication code.
   *
   * @param encoding the <code>AuthEnvelopedData</code> object as BER encoded byte array
   * @param key the key to decrypt the message
   * @param recipientCert the certificate of the recipient
   *
   * @return the recovered message, as byte array
   * @throws CMSException if the message cannot be recovered
   * @throws IOException if a stream read/write error occurs
   */
  public byte[] getAuthEnvelopedDataStream(byte[] encoding, Key key, X509Certificate recipientCert)
    throws CMSException, IOException {

    // create the AuthEnvelopedData object from a BER encoded byte array
    ByteArrayInputStream is = new ByteArrayInputStream(encoding);
    AuthEnvelopedDataStream authEnvelopedData = new AuthEnvelopedDataStream(is);

    System.out.println("Information about the encrypted data:");
    EncryptedContentInfoStream eci = (EncryptedContentInfoStream)authEnvelopedData.getEncryptedContentInfo();
    System.out.println("Content type: "+eci.getContentType().getName());
    System.out.println("Content encryption algorithm: "+eci.getContentEncryptionAlgorithm().getName());
    
    // decrypt the content encryption key and the content; verify mac
    try {
      System.out.println("Decrypt the content...");
      authEnvelopedData.setupCipher(key, recipientCert);
      InputStream decrypted = authEnvelopedData.getInputStream();
      ByteArrayOutputStream os = new ByteArrayOutputStream();
      Util.copyStream(decrypted, os, null);
      byte[] content = os.toByteArray();

      // get authenticated attributes
      Attribute contentTypeAttribute = authEnvelopedData.getAuthenticatedAttribute(ObjectID.contentType);
      if (contentTypeAttribute != null) {
        CMSContentType contentType = (CMSContentType)contentTypeAttribute.getAttributeValue();
        System.out.println("Authenticated content type attribute included: " + contentType.get().getName());
      }
      
      return content;
    } catch (InvalidKeyException ex) {
      throw new CMSException("Private key error: "+ex.toString());
    } catch (NoSuchAlgorithmException ex) {
      throw new CMSException("Content encryption algorithm not implemented: "+ex.toString());
    } catch (CodingException ex) {
      throw new CMSException("Error reading authenticated attributes: "+ex.toString());
    }
  }


  // non stream

  /**
   * Creates a CMS <code>AuthEnvelopedData</code> message.
   * 
   * @param message the message to be enveloped, as byte representation
   * @param keyEA the key encryption (key agreement) algorithm used for creating 
   *              a shared key encryption key for encrypting the secret content
   *              encryption key with it
   * @param keyWrapAlg the key wrap algorithm to be used for wrapping (encrypting) 
   *                   the content encryption key
   * @param kekLength the length of the key encryption key to be created for
   *                  encrypting the content encryption key with it    
   * @param contentAuthEncAlg the id of the content-authenticated encryption algorithm
   *
   * 
   * @return the encoded <code>AuthEnvelopedData</code>, as byte array
   * 
   * @throws CMSException if the <code>AuthEnvelopedData</code> object cannot
   *                          be created
   */
  public byte[] createAuthEnvelopedData(byte[] message, AlgorithmID keyEA, AlgorithmID keyWrapAlg,
    int kekLength, AlgorithmID contentAuthEncAlg)
    throws CMSException {
    
    AuthEnvelopedData authEnvelopedData;

    // create a new AuthEnvelopedData object
    authEnvelopedData = new AuthEnvelopedData(message, contentAuthEncAlg);
    
    //  create some authenticated attributes
    try {
      Attribute[] attributes = { new Attribute(new CMSContentType(ObjectID.cms_data)) };
      authEnvelopedData.setAuthenticatedAttributes(attributes);
    } catch (Exception ex) {
      throw new CMSException("Error creating attribute: " + ex.toString());   
    }
    
    // set the RecipientInfos
    RecipientInfo[] recipients = createRecipients(keyEA, keyWrapAlg, kekLength);
    authEnvelopedData.setRecipientInfos(recipients);

    // wrap into ContentInfo
    ContentInfo contentInfo = new ContentInfo(authEnvelopedData);
    // return encoded EnvelopedData
    return contentInfo.getEncoded();
  }


  /**
   * Decrypts the encrypted content of the given <code>AuthEnvelopedData</code> object for
   * the recipient identified by its index into the recipientInfos field and verifies
   * the message authentication code.
   * <p>
   * This way of decrypting the content may be used for any type of RecipientInfo
   * (KeyTransRecipientInfo, KeyAgreeRecipientInfo, KEKRecipientInfo), but requires to
   * know at what index of the recipientInfo field the RecipientInfo for the 
   * particular recipient in mind can be found. If the recipient in mind uses
   * a RecipientInfo of type KeyAgreeRecipientInfo some processing overhead may
   * take place because a KeyAgreeRecipientInfo may contain encrypted content-encryption
   * keys for more than only one recipient; since the recipientInfoIndex only
   * specifies the RecipientInfo but not the encrypted content encryption key 
   * -- if there are more than only one -- repeated decryption runs may be
   * required as long as the decryption process completes successfully.
   *
   * @param enc the encoded <code>AuthEnvelopedData</code>
   * 
   * @param key the key to decrypt the message
   * 
   * @param recipientInfoIndex the index into the <code>RecipientInfo</code> array
   *                    to which the specified key belongs
   *
   * @return the recovered message, as byte array
   * 
   * @throws CMSException if the message cannot be recovered
   * @throws IOException if an I/O error occurs
   */
  public byte[] getAuthEnvelopedData(byte[] enc, Key key, int recipientInfoIndex) 
    throws CMSException, IOException {
    ByteArrayInputStream bais = new ByteArrayInputStream(enc);
    AuthEnvelopedData authEnvelopedData = new AuthEnvelopedData(bais);

    System.out.println("Information about the encrypted data:");
    EncryptedContentInfo eci = (EncryptedContentInfo)authEnvelopedData.getEncryptedContentInfo();
    System.out.println("Content type: "+eci.getContentType().getName());
    System.out.println("Content encryption algorithm: "+eci.getContentEncryptionAlgorithm().getName());

    System.out.println("\nThis message can be decrypted by the owners of the following certificates:");
    RecipientInfo[] recipients = authEnvelopedData.getRecipientInfos();
    
    // for demonstration purposes we only look one time for all recipients included:
    if (recipientInfoIndex == 0) {
      int k = 0;
      for (int i=0; i<recipients.length; i++) {
        KeyIdentifier[] recipientIDs = recipients[i].getRecipientIdentifiers();
        for (int j = 0; j < recipientIDs.length; j++) {
          System.out.println("Recipient "+(++k)+":");
          System.out.println(recipientIDs[j]);
        }   
      }
    }
    
    // decrypt the message and verify the mac
    try {
      authEnvelopedData.setupCipher(key, recipientInfoIndex);
      byte[] content = authEnvelopedData.getContent();

      // get authenticated attributes
      Attribute contentTypeAttribute = authEnvelopedData.getAuthenticatedAttribute(ObjectID.contentType);
      if (contentTypeAttribute != null) {
        CMSContentType contentType = (CMSContentType)contentTypeAttribute.getAttributeValue();
        System.out.println("Authenticated content type attribute included: " + contentType.get().getName());
      }
      
      return content;
    } catch (InvalidKeyException ex) {
      throw new CMSException("Private key error: "+ex.toString());
    } catch (NoSuchAlgorithmException ex) {
      throw new CMSException("Content encryption algorithm not implemented: "+ex.toString());
    } catch (CodingException ex) {
      throw new CMSException("Error reading authenticated attributes: "+ex.toString());
    }
  }
  
  /**
   * Decrypts the encrypted content of the given <code>AuthEnvelopedData</code> object for
   * the recipient identified by recipient identifier.
   * <p>
   *
   * @param enc the BER encoded <code>AuthEnvelopedData</code> ASN.1 object
   * @param key the key to decrypt the message
   * @param recipientID the recipient identifier uniquely identifying the key of the
   *        recipient
   *
   * @return the recovered message, as byte array
   * @throws CMSException if the message cannot be recovered
   * @throws IOException if an I/O error occurs
   */
  public byte[] getAuthEnvelopedData(byte[] enc, Key key, KeyIdentifier recipientID) 
    throws CMSException, IOException {
    ByteArrayInputStream bais = new ByteArrayInputStream(enc);
    AuthEnvelopedData authEnvelopedData = new AuthEnvelopedData(bais);

    System.out.println("Information about the encrypted data:");
    EncryptedContentInfo eci = (EncryptedContentInfo)authEnvelopedData.getEncryptedContentInfo();
    System.out.println("Content type: "+eci.getContentType().getName());
    System.out.println("Content encryption algorithm: "+eci.getContentEncryptionAlgorithm().getName());

    // get the right RecipientInfo
    System.out.println("\nSearch for RecipientInfo:");
    RecipientInfo recipient = authEnvelopedData.getRecipientInfo(recipientID);
    if (recipient != null) {
      System.out.println("RecipientInfo: " + recipient);   
    } else {
      throw new CMSException("No recipient with ID: " + recipientID);
    }    
    // decrypt the content encryption key and the content
    try {
      System.out.println("Decrypt encrypted content encryption key...");
      SecretKey cek = recipient.decryptKey(key, recipientID);
      System.out.println("Decrypt content with decrypted content encryption key...");
      // decrypt content and verify mac      
      authEnvelopedData.setupCipher(cek);
      byte[] content = authEnvelopedData.getContent();

      // get authenticated attributes
      Attribute contentTypeAttribute = authEnvelopedData.getAuthenticatedAttribute(ObjectID.contentType);
      if (contentTypeAttribute != null) {
        CMSContentType contentType = (CMSContentType)contentTypeAttribute.getAttributeValue();
        System.out.println("Authenticated content type attribute included: " + contentType.get().getName());
      }
      
      return content;
    } catch (InvalidKeyException ex) {
      throw new CMSException("Private key error: "+ex.toString());
    } catch (NoSuchAlgorithmException ex) {
      throw new CMSException("Content encryption algorithm not implemented: "+ex.toString());
    } catch (CodingException ex) {
      throw new CMSException("Error reading authenticated attributes: "+ex.toString());
    }
  }
  
  /**
   * Decrypts the encrypted content of the given <code>AuthEnvelopedData</code> object for
   * the recipient identified by its recipient certificate or keyID.
   *
   * @param enc the BER encoded <code>AuthEnvelopedData</code> ASN.1 object
   * @param key the key to decrypt the message
   * @param recipientCert the certificate of the recipient 
   *
   * @return the recovered message, as byte array
   * @throws CMSException if the message cannot be recovered
   */
  public byte[] getAuthEnvelopedData(byte[] enc, Key key, X509Certificate recipientCert) 
    throws CMSException, IOException {
    ByteArrayInputStream bais = new ByteArrayInputStream(enc);
    AuthEnvelopedData authEnvelopedData = new AuthEnvelopedData(bais);

    System.out.println("Information about the encrypted data:");
    EncryptedContentInfo eci = (EncryptedContentInfo)authEnvelopedData.getEncryptedContentInfo();
    System.out.println("Content type: "+eci.getContentType().getName());
    System.out.println("Content encryption algorithm: "+eci.getContentEncryptionAlgorithm().getName());

    // decrypt the content encryption key and the content
    try {
      System.out.println("Decrypt the content and verify mac...");
      // decrypt content and verify mac
      authEnvelopedData.setupCipher(key, recipientCert);
      
      byte[] content = authEnvelopedData.getContent();

      // get authenticated attributes
      Attribute contentTypeAttribute = authEnvelopedData.getAuthenticatedAttribute(ObjectID.contentType);
      if (contentTypeAttribute != null) {
        CMSContentType contentType = (CMSContentType)contentTypeAttribute.getAttributeValue();
        System.out.println("Authenticated content type attribute included: " + contentType.get().getName());
      }
      
      return content;
    } catch (InvalidKeyException ex) {
      throw new CMSException("Private key error: "+ex.toString());
    } catch (NoSuchAlgorithmException ex) {
      throw new CMSException("Content encryption algorithm not implemented: "+ex.toString());
    } catch (CodingException ex) {
      throw new CMSException("Error reading authenticated attributes: "+ex.toString());
    }

  }
  
  /**
   * Creates the RecipientInfos.
   * 
   * @param keyEA the key encryption (key agreement) algorithm used for creating 
   *              a shared key encryption key for encrypting the secret content
   *              encryption key with it
   * @param keyWrapAlg the key wrap algorithm to be used for wrapping (encrypting) 
   *                   the content encryption key
   * @param kekLength the length of the key encryption key to be created for
   *                  encrypting the content encryption key with it              
   *
   * @return the RecipientInfos created, two KeyAgreeRecipientInfos
   *
   * @throws CMSException if an error occurs when creating the recipient infos
   */
  public RecipientInfo[] createRecipients(AlgorithmID keyEA, AlgorithmID keyWrapAlg, int kekLength) throws CMSException {
    // just for demonstration we use two recipients, one having a x25519 key, the other a x448 key
    RecipientInfo[] recipients = new RecipientInfo[2];
    try {
      recipients[0] = new KeyAgreeRecipientInfo((AlgorithmID)keyEA.clone(), (AlgorithmID)keyWrapAlg.clone(), kekLength);
      ((KeyAgreeRecipientInfo)recipients[0]).addRecipient(x25519User, CertificateIdentifier.ISSUER_AND_SERIALNUMBER);
  
      recipients[1] = new KeyAgreeRecipientInfo((AlgorithmID)keyEA.clone(), (AlgorithmID)keyWrapAlg.clone(), kekLength);
      ((KeyAgreeRecipientInfo)recipients[1]).addRecipient(x448User, CertificateIdentifier.RECIPIENT_KEY_IDENTIFIER);
      
    } catch (Exception ex) {
      throw new CMSException("Error adding recipients: " + ex.toString()); 
    }    
    return recipients;
  }  
  
  /**
   * Parses an AuthEnvelopedData and decrypts the content for all test recipients
   * using the index into the recipientInfos field for identifying the recipient.
   *
   * @param stream whether to use AuthEnvelopedDataStream or AuthEnvelopedData
   * @param encodedAuthEnvelopedData the encoded AuthEnvelopedData object 
   *
   * @throws Exception if some error occurs during decoding/decryption
   */ 
  public void parseAuthEnvelopedDataWithRecipientInfoIndex(boolean stream, byte[] encodedAuthEnvelopedData) throws Exception {
    byte[] receivedMessage;
    if (stream) {
      // x25519User
      System.out.println("\nDecrypt for x25519User:");
      receivedMessage = getAuthEnvelopedDataStream(encodedAuthEnvelopedData, x25519User_pk, 0);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
      // x448User
      System.out.println("\nDecrypt for x448User:");
      receivedMessage = getAuthEnvelopedDataStream(encodedAuthEnvelopedData, x448User_pk, 1);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));

    } else {
      // x25519User
      System.out.println("\nDecrypt for x25519User:");
      receivedMessage = getAuthEnvelopedData(encodedAuthEnvelopedData, x25519User_pk, 0);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
      // x448User
      System.out.println("\nDecrypt for x448User:");
      receivedMessage = getAuthEnvelopedData(encodedAuthEnvelopedData, x448User_pk, 1);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));

    }    
  }
  
  /**
   * Parses an AuthEnvelopedData and decrypts the content for all test recipients
   * using their recipient identifiers for identifying the recipient.
   *
   * @param stream whether to use AuthEnvelopedDataStream or AuthEnvelopedData
   * @param encodedAuthEnvelopedData the encoded AuthEnvelopedData object 
   *
   * @throws Exception if some error occurs during decoding/decryption
   */ 
  public void parseAuthEnvelopedDataWithRecipientIdentifier(boolean stream, byte[] encodedAuthEnvelopedData) throws Exception {
    byte[] receivedMessage;
    if (stream) {
      // x25519User
      System.out.println("\nDecrypt for x25519User:");
      receivedMessage = getAuthEnvelopedDataStream(encodedAuthEnvelopedData, x25519User_pk, new IssuerAndSerialNumber(x25519User));
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
      // x448User
      System.out.println("\nDecrypt for x448User:");
      receivedMessage = getAuthEnvelopedDataStream(encodedAuthEnvelopedData, x448User_pk, new RecipientKeyIdentifier(x448User));
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
    } else {
      // x25519User
      System.out.println("\nDecrypt for x25519User:");
      receivedMessage = getAuthEnvelopedData(encodedAuthEnvelopedData, x25519User_pk, new IssuerAndSerialNumber(x25519User));
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
      // x448User
      System.out.println("\nDecrypt for x448User:");
      receivedMessage = getAuthEnvelopedData(encodedAuthEnvelopedData, x448User_pk, new RecipientKeyIdentifier(x448User));
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
    }    
  }
  
  /**
   * Parses an AuthEnvelopedData and decrypts the content for all test recipients
   * using their recipient certificate for identifying the recipient.
   *
   * @param stream whether to use AuthEnvelopedDataStream or AuthEnvelopedData
   * @param encodedAuthEnvelopedData the encoded AuthEnvelopedData object 
   *
   * @throws Exception if some error occurs during decoding/decryption
   */ 
  public void parseAuthEnvelopedDataWithRecipientCert(boolean stream, byte[] encodedAuthEnvelopedData) throws Exception {
    byte[] receivedMessage;
    if (stream) {
      // x25519User
      System.out.println("\nDecrypt for x25519User:");
      receivedMessage = getAuthEnvelopedDataStream(encodedAuthEnvelopedData, x25519User_pk, x25519User);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
      // x448User
      System.out.println("\nDecrypt for x448User:");
      receivedMessage = getAuthEnvelopedDataStream(encodedAuthEnvelopedData, x448User_pk, x448User);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
    } else {
      // x25519User
      System.out.println("\nDecrypt for x25519User:");
      receivedMessage = getAuthEnvelopedData(encodedAuthEnvelopedData, x25519User_pk, x25519User);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
      // x448User
      System.out.println("\nDecrypt for x448User:");
      receivedMessage = getAuthEnvelopedData(encodedAuthEnvelopedData, x448User_pk, x448User);
      System.out.print("\nDecrypted content: ");
      System.out.println(new String(receivedMessage));
    }    
  }
  
  /**
   * Starts the test.
   */
  public void start() {
  
    AlgorithmID[] keyEAs = {
        AlgorithmID.dhSinglePass_stdDH_sha256kdf_scheme, 
        AlgorithmID.dhSinglePass_stdDH_sha384kdf_scheme, 
        AlgorithmID.dhSinglePass_stdDH_hkdf_sha256_scheme, 
        AlgorithmID.dhSinglePass_stdDH_hkdf_sha384_scheme,
        AlgorithmID.dhSinglePass_stdDH_hkdf_sha512_scheme, 
    };
    
    AlgorithmID[] keyWrapAlgs = {
        CMSAlgorithmID.cms_aes128_wrap, 
        CMSAlgorithmID.cms_aes192_wrap, 
        CMSAlgorithmID.cms_aes256_wrap, 
    };
    
    for (int i = 0; i < keyEAs.length; i++) {
      AlgorithmID[] contentEAs = { AlgorithmID.aes256_GCM, AlgorithmID.aes256_CCM, AlgorithmID.chacha20Poly1305 };
      AlgorithmID keyEA = keyEAs[i];
      for (int j = 0; j < keyWrapAlgs.length; j++) {
        AlgorithmID keyWrapAlg = keyWrapAlgs[j];
        int kekLength = 256;
        if (keyWrapAlg.equals(CMSAlgorithmID.cms_aes192_wrap)) {
          kekLength = 192;
          contentEAs = new AlgorithmID[] { AlgorithmID.aes192_GCM, AlgorithmID.aes192_CCM };
        } else if (keyWrapAlg.equals(CMSAlgorithmID.cms_aes128_wrap)) {
          kekLength = 128;
          contentEAs = new AlgorithmID[] { AlgorithmID.aes128_GCM, AlgorithmID.aes128_CCM };
        }
        
        for (int k = 0; k < contentEAs.length; k++) {
          AlgorithmID contentAuthEncAlg = (AlgorithmID)contentEAs[k].clone();
          System.out.println("EdDH AuthEnveloped demo for " + keyEA.getName() + " with " + keyWrapAlg.getName() +" and " + contentAuthEncAlg.getName());
          start(keyEA, keyWrapAlg, kekLength, contentAuthEncAlg);
        }
      }
    } 
  }
  
  /**
   * Starts the test for the given content-authenticated encryption algorithm.
   * 
   * @param keyEA the key encryption (key agreement) algorithm used for creating 
   *              a shared key encryption key for encrypting the secret content
   *              encryption key with it
   * @param keyWrapAlg the key wrap algorithm to be used for wrapping (encrypting) 
   *                   the content encryption key
   * @param kekLength the length of the key encryption key to be created for
   *                  encrypting the content encryption key with it       
   * @param contentAuthEncAlg the id of the content-authenticated encryption algorithm
   */
  public void start(AlgorithmID keyEA, AlgorithmID keyWrapAlg, int kekLength, AlgorithmID contentAuthEncAlg) {
     // the test message
    String m = "This is the test message.";
    System.out.println("Test message: \""+m+"\"");
    System.out.println();
    byte[] message = m.getBytes();

    try {
      byte[] encodedAuthEnvelopedData;
      System.out.println("Stream implementation demos");
      System.out.println("===========================");

      // the stream implementation
      //
      // test CMS AuthEnvelopedDataStream
      //
      System.out.println("\nCMS AuthEnvelopedDataStream demo [create]:\n");
      encodedAuthEnvelopedData = createAuthEnvelopedDataStream(message, keyEA, keyWrapAlg, kekLength, (AlgorithmID)contentAuthEncAlg.clone());
      // transmit data
      System.out.println("\nCMS AuthEnvelopedDataStream demo [parse]:\n");
      System.out.println("Decrypt for the several recipients using their index into the recipientInfos field.");
      parseAuthEnvelopedDataWithRecipientInfoIndex(true, encodedAuthEnvelopedData);
      System.out.println("Decrypt for the several recipients using their RecipientIdentifier.");
      parseAuthEnvelopedDataWithRecipientIdentifier(true, encodedAuthEnvelopedData);
      System.out.println("Decrypt for the several recipients using their certificate.");
      parseAuthEnvelopedDataWithRecipientCert(true, encodedAuthEnvelopedData);
      
      
      // the output stream implementation
      //
      // test CMS AuthEnvelopedDataOutputStream
      //
      System.out.println("\nCMS AuthEnvelopedDataOutputStream demo [create]:\n");
      encodedAuthEnvelopedData = createAuthEnvelopedDataOutputStream(message, keyEA, keyWrapAlg, kekLength, (AlgorithmID)contentAuthEncAlg.clone());
      // transmit data
      System.out.println("\nCMS AuthEnvelopedDataStream demo [parse]:\n");
      System.out.println("Decrypt for the several recipients using their index into the recipientInfos field.");
      parseAuthEnvelopedDataWithRecipientInfoIndex(true, encodedAuthEnvelopedData);
      System.out.println("Decrypt for the several recipients using their RecipientIdentifier.");
      parseAuthEnvelopedDataWithRecipientIdentifier(true, encodedAuthEnvelopedData);
      System.out.println("Decrypt for the several recipients using their certificate.");
      parseAuthEnvelopedDataWithRecipientCert(true, encodedAuthEnvelopedData);

      // the non-stream implementation
      System.out.println("\nNon-stream implementation demos");
      System.out.println("===============================");

            
      //
      // test CMS AuthEnvelopedData
      //
      System.out.println("\nCMS AuthEnvelopedData demo [create]:\n");
      encodedAuthEnvelopedData = createAuthEnvelopedData(message, keyEA, keyWrapAlg, kekLength, (AlgorithmID)contentAuthEncAlg.clone());
      // transmit data
      System.out.println("\nCMS AuthEnvelopedData demo [parse]:\n");
      System.out.println("Decrypt for the several recipients using their index into the recipientInfos field.");
      parseAuthEnvelopedDataWithRecipientInfoIndex(false, encodedAuthEnvelopedData);
      System.out.println("Decrypt for the several recipients using their RecipientIdentifier.");
      parseAuthEnvelopedDataWithRecipientIdentifier(false, encodedAuthEnvelopedData);
      System.out.println("Decrypt for the several recipients using their certificate.");
      parseAuthEnvelopedDataWithRecipientCert(false, encodedAuthEnvelopedData);
      

        } catch (Exception ex) {
          ex.printStackTrace();
          throw new RuntimeException(ex.toString());
        }
  }
  
  
  /**
   * Main method.
   *
   * @throws IOException
   *            if an I/O error occurs when reading required keys
   *            and certificates from files
   */
  public static void main(String argv[]) throws Exception {

    DemoUtil.initDemos();
    ECCDemoUtil.installIaikEccProvider();

    (new EdDHAuthEnvelopedDataDemo()).start();
    System.out.println("\nReady!");
    DemoUtil.waitKey();
  }
  
}