// 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/smime/basic/SMimeV4Demo.java 8     12.02.25 17:59 Dbratko $
// $Revision: 8 $
//

package demo.smime.basic;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.util.Date;

import jakarta.activation.DataHandler;
import jakarta.activation.FileDataSource;
import jakarta.mail.Message;
import jakarta.mail.MessagingException;
import jakarta.mail.Multipart;
import jakarta.mail.Session;
import jakarta.mail.internet.InternetAddress;
import jakarta.mail.internet.MimeBodyPart;
import jakarta.mail.internet.MimeMessage;
import jakarta.mail.internet.MimeMultipart;

import demo.DemoSMimeUtil;
import demo.DemoUtil;
import demo.keystore.CMSKeyStore;
import demo.smime.DumpMessage;
import iaik.asn1.ObjectID;
import iaik.asn1.structures.AlgorithmID;
import iaik.asn1.structures.Name;
import iaik.cms.CMSAlgorithmID;
import iaik.pkcs.PKCSException;
import iaik.pkcs.pkcs10.CertificateRequest;
import iaik.smime.AuthEncryptedContent;
import iaik.smime.CompressedContent;
import iaik.smime.EncryptedContent;
import iaik.smime.PKCS10Content;
import iaik.smime.SMimeBodyPart;
import iaik.smime.SMimeMultipart;
import iaik.smime.SMimeParameters;
import iaik.smime.SignedContent;
import iaik.x509.X509Certificate;

/**
 * This class demonstrates the usage of the IAIK S/MIME implementation. It shows how to create
 * signed and/or encrypted S/MIMEv4 messages and how to parse them and verify the signatures 
 * and decrypt the content, respectively.
 * <p>
 * To run this demo the following packages are required:
 * <ul>
 *    <li>
 *       <code>iaik_cms.jar</code> (IAIK-CMS/SMIME)
 *    </li>
 *    <li>
 *       <code>iaik_jce(_full).jar</code> (<a href="https://sic.tech/products/core-crypto-toolkits/jca-jce/" target="_blank">IAIK-JCE Core Crypto Library</a>).
 *    </li>
 *    <li>
 *       <a href="https://jakarta.ee/specifications/mail/" target="_blank">Jakarta</a>/<a href="https://eclipse-ee4j.github.io/angus-mail/" target="_blank">Angus</a> Mail
 *    </li>   
 *    <li>
 *       <a href="https://jakarta.ee/specifications/activation/" target="_blank">Jakarta Activation Framework</a>
 *    </li> 
 * </ul>
 * You also will need the IAIK-JCE library, <code>iaik_jce(_full).jar</code>.
 * <p>
 * This demo uses RSA both for signing an encryption. Look at the demos in package <code>demo.smime.ecc</code> for
 * examples based on elliptic curve cryptography.
 * 
 */
public class SMimeV4Demo {
    
  // whether to print dump all generates test messages to System.out
  final static boolean PRINT_MESSAGES = false;   
  

  String firstName_ = "John";
  String lastName_ = "SMime";
  String to_ = "smimetest@iaik.tugraz.at";     // email recipient
  String from_ = "smimetest@iaik.tugraz.at";   // email sender
  String host_ = "mailhost";                   // name of the mailhost

  X509Certificate[] signerCertificates_;       // list of certificates to include in the S/MIME message
  X509Certificate signerCertificate_;          // certificate of the signer/sender
  PrivateKey signerPrivateKey_;                // private key of the signer/sender
  
  X509Certificate senderCryptCertificate_;     // the encryption certificate of the signer/sender
  
  X509Certificate rsaRecipientCertificate_;    // RSA encryption cert and key of a recipient
  
  /**
   * Default constructor. Reads certificates and keys from the demo keystore.
   */
  public SMimeV4Demo() {
    
    System.out.println();
    System.out.println("********************************************************************************************");
    System.out.println("*                                SMimeV4Demo demo                                          *");
    System.out.println("* (shows how to create and parse (verify, decrypt) signed and encrypted S/MIMEv4 messages) *");
    System.out.println("********************************************************************************************");
    System.out.println();
    
    // get the certificates from the KeyStore
    signerCertificates_ = CMSKeyStore.getCertificateChain(CMSKeyStore.RSA, CMSKeyStore.SZ_2048_SIGN_1);
    signerPrivateKey_ = CMSKeyStore.getPrivateKey(CMSKeyStore.RSA, CMSKeyStore.SZ_2048_SIGN_1);
    signerCertificate_ = signerCertificates_[0];
    senderCryptCertificate_ = CMSKeyStore.getCertificateChain(CMSKeyStore.RSA, CMSKeyStore.SZ_2048_CRYPT_1)[0];

    rsaRecipientCertificate_ = CMSKeyStore.getCertificateChain(CMSKeyStore.RSA, CMSKeyStore.SZ_2048_CRYPT_2)[0];

  }
  
  /**
   * Starts the demo.
   *
   * @throws IOException if an I/O related error occurs
   */
  public void start() throws IOException {

    // get the default Session
        Session session = DemoSMimeUtil.getSession();

        try {
      // Create a demo Multipart
      MimeBodyPart mbp1 = new SMimeBodyPart();
          mbp1.setText("This is a Test of the IAIK S/MIME implementation!\n\n");
          // attachment
      MimeBodyPart attachment = new SMimeBodyPart();
      attachment.setDataHandler(new DataHandler(new FileDataSource("test.html")));
      attachment.setFileName("test.html");

      Multipart mp = new SMimeMultipart();
      mp.addBodyPart(mbp1);
      mp.addBodyPart(attachment);
      DataHandler multipart = new DataHandler(mp, mp.getContentType());

      Message msg;    // the message to send
      ByteArrayOutputStream baos = new ByteArrayOutputStream(); // we write to a stream
      ByteArrayInputStream bais;  // we read from a stream

      // This is a plain message
      msg = createPlainMessage(session, multipart);
      System.out.println("creating plain message...");
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");

      // This is an explicitly signed message
      msg = createSignedMessage(session, multipart, false, AlgorithmID.sha256, AlgorithmID.rsaEncryption);
      System.out.println("creating explicitly signed message...");
      baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");


      // This is an implicitly signed message
      msg = createSignedMessage(session, multipart, true, AlgorithmID.sha256, AlgorithmID.rsaEncryption);
      System.out.println("creating implicitly signed message...");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");

      // Now create encrypted messages with different content encryption algorithms
          
          msg = createEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_CBC.clone(), 128);
      System.out.println("creating encrypted message [AES/128]...");
      baos.reset();
      msg.saveChanges();
      msg.writeTo(baos);
      bais = new ByteArrayInputStream(baos.toByteArray());
      msg = new MimeMessage(session, bais);
      if (PRINT_MESSAGES) {
        printMessage(msg);
      }
      DumpMessage.dumpEncryptedMessage(msg);
      
      System.out.println("\n\n*****************************************\n\n");
      
      msg = createEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_CBC.clone(), 192);
      System.out.println("creating encrypted message [AES/192]...");
      baos.reset();
      msg.saveChanges();
      msg.writeTo(baos);
      bais = new ByteArrayInputStream(baos.toByteArray());
      msg = new MimeMessage(session, bais);
      if (PRINT_MESSAGES) {
        printMessage(msg);
      }
      DumpMessage.dumpEncryptedMessage(msg);
        
      System.out.println("\n\n*****************************************\n\n");
        
      msg = createEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_CBC.clone(), 256);
      System.out.println("creating encrypted message [AES/256]...");
      baos.reset();
      msg.saveChanges();
      msg.writeTo(baos);
      bais = new ByteArrayInputStream(baos.toByteArray());
      msg = new MimeMessage(session, bais);
      if (PRINT_MESSAGES) {
        printMessage(msg);
      }
      DumpMessage.dumpEncryptedMessage(msg);
       
      System.out.println("\n\n*****************************************\n\n");

      // Now create an implicitly signed and encrypted message with attachment
      msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_CBC.clone(), 128, multipart, true, false);
      System.out.println("creating implicitly signed and encrypted message [AES/128]...");
      baos.reset();
      msg.saveChanges();
      msg.writeTo(baos);
      bais = new ByteArrayInputStream(baos.toByteArray());
      msg = new MimeMessage(session, bais);
      if (PRINT_MESSAGES) {
        printMessage(msg);
      }
      DumpMessage.dumpEncryptedMessage(msg);
      
      System.out.println("\n\n*****************************************\n\n");
      
      // Now create an implicitly signed and encrypted message with attachment
      msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_CBC.clone(), 192, multipart, true, false);
      System.out.println("creating implicitly signed and encrypted message [AES/192]...");
      baos.reset();
      msg.saveChanges();
      msg.writeTo(baos);
      bais = new ByteArrayInputStream(baos.toByteArray());
      msg = new MimeMessage(session, bais);
      if (PRINT_MESSAGES) {
        printMessage(msg);
      }
      DumpMessage.dumpEncryptedMessage(msg);
      
      System.out.println("\n\n*****************************************\n\n");

      // Now create an explicitly signed and encrypted message with attachment
      msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_CBC.clone(), 192, multipart, false, false);;
      System.out.println("creating explicitly signed and encrypted message [AES/192]...");
      baos.reset();
      msg.saveChanges();
      msg.writeTo(baos);
      bais = new ByteArrayInputStream(baos.toByteArray());
      msg = new MimeMessage(session, bais);
      if (PRINT_MESSAGES) {
        printMessage(msg);
      }
      DumpMessage.dumpEncryptedMessage(msg);
      
      System.out.println("\n\n*****************************************\n\n");

      // Now create an implicitly signed and encrypted message with attachment
      msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_CBC.clone(), 256, multipart, true, false);
      System.out.println("creating implicitly signed and encrypted message [AES/256]...");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpEncryptedMessage(msg);
          
          System.out.println("\n\n*****************************************\n\n");

      // Now create an explicitly signed and encrypted message with attachment
      msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_CBC.clone(), 256, multipart, false, false);;
      System.out.println("creating explicitly signed and encrypted message [AES/256]...");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpEncryptedMessage(msg);
          
          System.out.println("\n\n*****************************************\n\n");
          
          // Now create authenticated encrypted messages with different content encryption algorithms
          if (DemoUtil.getIaikProviderVersion() >= 5.62) {
            
            msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_GCM.clone(), 128);
        System.out.println("creating authenticated encrypted message [AES-GCM/128]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
         
        System.out.println("\n\n*****************************************\n\n");
        
        msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_GCM.clone(), 192);
        System.out.println("creating authenticated encrypted message [AES-GCM/192]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg); 
         
        System.out.println("\n\n*****************************************\n\n");
            
            msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_GCM.clone(), 256);
            System.out.println("creating authenticated encrypted message [AES-GCM/256]...");
            baos.reset();
            msg.saveChanges();
            msg.writeTo(baos);
            bais = new ByteArrayInputStream(baos.toByteArray());
            msg = new MimeMessage(session, bais);
            if (PRINT_MESSAGES) {
              printMessage(msg);
            }
            DumpMessage.dumpEncryptedMessage(msg);
             
            System.out.println("\n\n*****************************************\n\n");
            
            msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_CCM.clone(), 128);
        System.out.println("creating authenticated encrypted message [AES-CCM/128]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
         
        System.out.println("\n\n*****************************************\n\n");
        
        msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_CCM.clone(), 192);
        System.out.println("creating authenticated encrypted message [AES-CCM/192]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg); 
        
        msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_CCM.clone(), 256);
        System.out.println("creating authenticated encrypted message [AES-CCM/256]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
         
        System.out.println("\n\n*****************************************\n\n");
        
        msg = createAuthEncryptedMessage(session, (AlgorithmID)AlgorithmID.chacha20Poly1305.clone(), 256);
        System.out.println("creating authenticated encrypted message [ChaChaPoly1305]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);  
         
        System.out.println("\n\n*****************************************\n\n");
        
       // Create an implicitly signed and authenticated encrypted message with attachment
        msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_GCM.clone(), 128, multipart, true, true);
        System.out.println("creating implicitly signed and authenticated encrypted message [AES-GCM/128]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
        
        System.out.println("\n\n*****************************************\n\n");

        // Create an explicitly signed and authenticated encrypted message with attachment
        msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_GCM.clone(), 128, multipart, true, true);
        System.out.println("creating explicitly signed and authenticated encrypted message [AES-GCM/128]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
        
        System.out.println("\n\n*****************************************\n\n");
        
        // Create an implicitly signed and authenticated encrypted message with attachment
        msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_GCM.clone(), 192, multipart, true, true);
        System.out.println("creating implicitly signed and authenticated encrypted message [AES-GCM/192]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
        
        System.out.println("\n\n*****************************************\n\n");

        // Create an explicitly signed and authenticated encrypted message with attachment
        msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_GCM.clone(), 192, multipart, true, true);
        System.out.println("creating explicitly signed and authenticated encrypted message [AES-GCM/192]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
        
        System.out.println("\n\n*****************************************\n\n");
            
        // Create an implicitly signed and authenticated encrypted message with attachment
        msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_GCM.clone(), 256, multipart, true, true);
        System.out.println("creating implicitly signed and authenticated encrypted message [AES-GCM/256]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
        
        System.out.println("\n\n*****************************************\n\n");

        // Create an explicitly signed and authenticated encrypted message with attachment
        msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_GCM.clone(), 256, multipart, true, true);
        System.out.println("creating explicitly signed and authenticated encrypted message [AES-GCM/256]...");
        baos.reset();
        msg.saveChanges();
        msg.writeTo(baos);
        bais = new ByteArrayInputStream(baos.toByteArray());
        msg = new MimeMessage(session, bais);
        if (PRINT_MESSAGES) {
          printMessage(msg);
        }
        DumpMessage.dumpEncryptedMessage(msg);
        
        System.out.println("\n\n*****************************************\n\n");
        
        
        // Create an implicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_CCM.clone(), 128, multipart, true, true);
         System.out.println("creating implicitly signed and authenticated encrypted message [AES-CCM/128]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");

         // Create an explicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes128_CCM.clone(), 128, multipart, true, true);
         System.out.println("creating explicitly signed and authenticated encrypted message [AES-CCM/128]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");
         
         // Create an implicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_CCM.clone(), 192, multipart, true, true);
         System.out.println("creating implicitly signed and authenticated encrypted message [AES-CCM/192]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");

         // Create an explicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes192_CCM.clone(), 192, multipart, true, true);
         System.out.println("creating explicitly signed and authenticated encrypted message [AES-CCM/192]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");
         
         // Create an implicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_CCM.clone(), 256, multipart, true, true);
         System.out.println("creating implicitly signed and authenticated encrypted message [AES-CCM/256]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");

         // Create an explicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.aes256_CCM.clone(), 256, multipart, true, true);
         System.out.println("creating explicitly signed and authenticated encrypted message [AES-CCM/256]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");
        
         // Create an implicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.chacha20Poly1305.clone(), 256, multipart, true, true);
         System.out.println("creating implicitly signed and authenticated encrypted message [ChaCha20Poly1305]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");

         // Create an explicitly signed and authenticated encrypted message with attachment
         msg = createSignedAndEncryptedMessage(session, (AlgorithmID)AlgorithmID.chacha20Poly1305.clone(), 256, multipart, true, true);
         System.out.println("creating explicitly signed and authenticated encrypted message [ChaCha20Poly1305]...");
         baos.reset();
         msg.saveChanges();
         msg.writeTo(baos);
         bais = new ByteArrayInputStream(baos.toByteArray());
         msg = new MimeMessage(session, bais);
         if (PRINT_MESSAGES) {
           printMessage(msg);
         }
         DumpMessage.dumpEncryptedMessage(msg);
         
         System.out.println("\n\n*****************************************\n\n");
            
          }
         
          // certs only message
          msg = createCertsOnlyMessage(session);
          System.out.println("creating certs-only message");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");

          // second certs only message
          msg = createCertsOnlyMultiPartMessage(session);
          System.out.println("creating message with certs-only part");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");

          // application/pkcs10 cert request message
      msg = createPKCS10Message(session);
      System.out.println("creating application/pkcs10 message...");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");

          // sending application/pkcs10 message where the request is in the second part
          msg = createPKCS10MultiPartMessage(session);
          System.out.println("creating message with pkcs10 part...");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);
          
          System.out.println("\n\n*****************************************\n\n");

          // compressed message 
          msg = createCompressedMessage(session, multipart, (AlgorithmID)CMSAlgorithmID.zlib_compress.clone());
          System.out.println("creating message with compressed data...");
          baos.reset();
          msg.saveChanges();
          msg.writeTo(baos);
          bais = new ByteArrayInputStream(baos.toByteArray());
          msg = new MimeMessage(session, bais);
          if (PRINT_MESSAGES) {
        printMessage(msg);
      }
          DumpMessage.dumpMsg(msg);

        } catch (Exception ex) {
            ex.printStackTrace();
            throw new RuntimeException(ex.toString());
        }
  }

  /**
   * Creates a MIME message container with the given subject for the given session.
   * 
   * @param session the mail sesion
   * @param subject the subject of the message
   *
   * @return the MIME message with FROM, TO, DATE and SUBJECT headers (without content)
   *
   * @throws MessagingException if the message cannot be created
   */
  public Message createMessage(Session session, String subject) throws MessagingException {
    MimeMessage msg = new MimeMessage(session);
    msg.setFrom(new InternetAddress(from_));
        msg.setRecipients(Message.RecipientType.TO,     InternetAddress.parse(to_, false));
        msg.setSentDate(new Date());
    msg.setSubject(subject);
    return msg;
  }
  
  /**
   * Creates a simple plain (neither signed nor encrypted) message.
   *
   * @param session the mail session
   * @param dataHandler the content of the message
   * 
   * @return the plain message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createPlainMessage(Session session, DataHandler dataHandler) throws MessagingException {

    Message msg = createMessage(session, "IAIK-S/MIME: Plain message");
    if (dataHandler != null) {
      msg.setDataHandler(dataHandler);
    } else {
      msg.setText("This is a plain message!\nIt is wether signed nor encrypted!\n");
    }
    return msg;
  }
  
  /**
   * Creates a signed and encrypted message.
   *
   * @param session the mail session
   * @param contentEA the content encryption algorithm to be used
   * @param keyLength the length of the secret content encryption key to be created and used
   * @param dataHandler the content of the message to be signed and encrypted
   * @param implicit whether to use implicit (application/pkcs7-mime) or explicit
   *                 (multipart/signed) signing
   * @param authEncrypt whether to create an authenticated encrypted message                
   * 
   * @return the signed and encrypted message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createSignedAndEncryptedMessage(Session session, 
    AlgorithmID contentEA, int keyLength,
    DataHandler dataHandler, boolean implicit, boolean authEncrypt)
    throws MessagingException {

    String subject = null;
    String text = null;
    if (implicit) {
      subject = "IAIK-S/MIME: Implicitly signed and " + (authEncrypt ? "authenticated " : "") + "encrypted";
      text = "This message is implicitly signed and " + (authEncrypt ? "authenticated " : "") + "encrypted!\n\n\n";
    } else {
      subject = "IAIK-S/MIME: explicitly signed and " + (authEncrypt ? "authenticated " : "") + " encrypted";
      text = "This message is explicitly signed and " + (authEncrypt ? "authenticated " : "") + " encrypted!\n\n\n";
    }
    Message msg = createMessage(session, subject);

    SignedContent sc = new SignedContent(implicit);
    if (dataHandler != null) {
      sc.setDataHandler(dataHandler);
    } else {
      sc.setText(text);
    }
    sc.setCertificates(signerCertificates_);
    try {
      sc.addSigner(signerPrivateKey_, 
                   signerCertificate_,
                   (AlgorithmID)AlgorithmID.sha256.clone(),
                   (AlgorithmID)AlgorithmID.rsaEncryption.clone());
    } catch (NoSuchAlgorithmException ex) {
      throw new MessagingException("Algorithm not supported: " + ex.getMessage(), ex);
    }

    EncryptedContent ec = null;
    if (authEncrypt) {
      ec = new AuthEncryptedContent(sc);
    } else {
      ec = new EncryptedContent(sc);
    }

    
    AlgorithmID algorithm = (AlgorithmID)contentEA.clone();
    
    // sender wants to be able to decrypt the message
    ec.addRecipient(senderCryptCertificate_, (AlgorithmID)AlgorithmID.rsaEncryption.clone());  
     
    // add RSA recipient
    ec.addRecipient(rsaRecipientCertificate_, (AlgorithmID)AlgorithmID.rsaEncryption.clone());
    // set the encryption algorithm
    try {
      ec.setEncryptionAlgorithm(algorithm, keyLength);
    } catch (NoSuchAlgorithmException ex) {
      throw new MessagingException("Content encryption algorithm not supported: " + ex.getMessage());   
    }   
    msg.setContent(ec, ec.getContentType());
    // let the EncryptedContent update some message headers
    ec.setHeaders(msg);

    return msg;
  }
  
  /**
   * Creates a signed message.
   *
   * @param session the mail session
   * @param dataHandler the content of the message to be signed
   * @param implicit whether to use implicit (application/pkcs7-mime) or explicit
   *                 (multipart/signed) signing
   * @param digestAlgorithm the digest algorithm to be used
   * @param signatureAlgorithm the signature algorithm to be used                
   * 
   * @return the signed message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createSignedMessage(Session session, 
                                     DataHandler dataHandler,
                                     boolean implicit,
                                     AlgorithmID digestAlgorithm,
                                     AlgorithmID signatureAlgorithm)
      throws MessagingException {

    String subject = null;
    StringBuffer buf = new StringBuffer();
    
    if (implicit) {
      subject = "IAIK-S/MIME: Implicitly Signed";
      buf.append("This message is implicitly signed!\n");
      buf.append("You need an S/MIME aware mail client to view this message.\n");
      buf.append("\n\n");
    } else {
      subject = "IAIK-S/MIME: Explicitly Signed";
      buf.append("This message is explicitly signed!\n");
      buf.append("Every mail client can view this message.\n");
      buf.append("Non S/MIME mail clients will show the signature as attachment.\n");
      buf.append("\n\n");
    }
    
    Message msg = createMessage(session, subject);
    
    SignedContent sc = new SignedContent(implicit);
    if (dataHandler != null) {
      sc.setDataHandler(dataHandler);
    } else {
      sc.setText(buf.toString());
    }
    sc.setCertificates(signerCertificates_);

    try {
      sc.addSigner(signerPrivateKey_, 
                   signerCertificate_,
                   (AlgorithmID)digestAlgorithm.clone(),
                   (AlgorithmID)signatureAlgorithm.clone());
    } catch (NoSuchAlgorithmException ex) {
      throw new MessagingException("Algorithm not supported: " + ex.getMessage(), ex);
    }

    msg.setContent(sc, sc.getContentType());
    // let the SignedContent update some message headers
    sc.setHeaders(msg);
    return msg;
  }
  
  /**
   * Creates an encrypted message.
   *
   * @param session the mail session
   * @param contentEA the content encryption algorithm to be used
   * @param keyLength the length of the secret content encryption key to be created and used
   * 
   * @return the encrypted message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createEncryptedMessage(Session session, AlgorithmID contentEA, int keyLength)
    throws MessagingException {
    
    AlgorithmID algorithm = (AlgorithmID)contentEA.clone();
    
    StringBuffer subject = new StringBuffer();
    subject.append("IAIK-S/MIME: Encrypted ["+algorithm.getName());
    if (keyLength > 0) {
      subject.append("/"+keyLength);
    }  
    subject.append("]");
    Message msg = createMessage(session, subject.toString());

    EncryptedContent ec = new EncryptedContent();

    StringBuffer buf = new StringBuffer();
    buf.append("This is the encrypted content!\n");
    buf.append("Content encryption algorithm: "+algorithm.getName());
    buf.append("\n\n");

    ec.setText(buf.toString());
    
    // sender wants to be able to decrypt the message
    ec.addRecipient(senderCryptCertificate_, (AlgorithmID)AlgorithmID.rsaEncryption.clone());  
   
    // add RSA recipient
    ec.addRecipient(rsaRecipientCertificate_, (AlgorithmID)AlgorithmID.rsaEncryption.clone());
    try {
      ec.setEncryptionAlgorithm(algorithm, keyLength);
    } catch (NoSuchAlgorithmException ex) {
      throw new MessagingException("Content encryption algorithm not supported: " + ex.getMessage());   
    }    

    msg.setContent(ec, ec.getContentType());
    // let the EncryptedContent update some message headers
    ec.setHeaders(msg);

    return msg;
  }
  
  /**
   * Creates an authenticated encrypted message.
   *
   * @param session the mail session
   * @param contentEA the content encryption algorithm to be used
   * @param keyLength the length of the secret content encryption key to be created and used
   * 
   * @return the encrypted message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createAuthEncryptedMessage(Session session, AlgorithmID contentEA, int keyLength)
      throws MessagingException {
    
    AlgorithmID algorithm = (AlgorithmID)contentEA.clone();
   
    StringBuffer subject = new StringBuffer();
    subject.append("IAIK-S/MIME: Authenticated Encrypted ["+algorithm.getName());
    if (keyLength > 0) {
      subject.append("/"+keyLength);
    }  
    subject.append("]");
    Message msg = createMessage(session, subject.toString());

    AuthEncryptedContent ec = new AuthEncryptedContent();

    StringBuffer buf = new StringBuffer();
    buf.append("This is the authenticated encrypted content!\n");
    buf.append("Content encryption algorithm: "+algorithm.getName());
    buf.append("\n\n");

    ec.setText(buf.toString());
    
    // sender wants to be able to decrypt the message
    ec.addRecipient(senderCryptCertificate_, (AlgorithmID)AlgorithmID.rsaEncryption.clone()); 
    
    // add RSA recipient 
    ec.addRecipient(rsaRecipientCertificate_, (AlgorithmID)AlgorithmID.rsaEncryption.clone());
    try {
      ec.setEncryptionAlgorithm(algorithm, keyLength);
    } catch (NoSuchAlgorithmException ex) {
      throw new MessagingException("Content encryption algorithm not supported: " + ex.getMessage());   
    }    

    msg.setContent(ec, ec.getContentType());
    // let the EncryptedContent update some message headers
    ec.setHeaders(msg);

    return msg;
  }
  
  /**
   * Creates a certs-only message.
   *
   * @param session the mail session
   * 
   * @return the certs-only message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createCertsOnlyMessage(Session session)
      throws MessagingException {

    Message msg = createMessage(session, "IAIK S/MIME: Certs-only message");
    //use new content types
    SMimeParameters.useNewContentTypes(true);
    SignedContent sc = new SignedContent(true, SignedContent.CERTS_ONLY);
    sc.setCertificates(signerCertificates_);
    msg.setContent(sc, sc.getContentType());
    //set filename and attachment parameters
    sc.setHeaders(msg);

    return msg;
  }
  
  
  /**
   * Creates a certs-only message where the certificate list is transferred as attachment.
   *
   * @param session the mail session
   * 
   * @return the certs-only message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createCertsOnlyMultiPartMessage(Session session) throws MessagingException {

    MimeBodyPart mbp1 = new MimeBodyPart();
        mbp1.setText("This is a test where the certs-only message is included in the second part!\n\n");

    MimeBodyPart attachment = new MimeBodyPart();
    //use new content types
    SMimeParameters.useNewContentTypes(true);
    SignedContent sc = new SignedContent(true, SignedContent.CERTS_ONLY);
    sc.setCertificates(signerCertificates_);
    attachment.setContent(sc, sc.getContentType());
    // let the SignedContent update some headers
    sc.setHeaders(attachment);
    Multipart mp = new MimeMultipart();
    mp.addBodyPart(mbp1);
    mp.addBodyPart(attachment);

    Message msg = createMessage(session, "IAIK S/MIME: Certs-only multipart message");
    msg.setContent(mp, mp.getContentType());
    return msg;
  }
  
   /**
   * Creates a compressed message.
   *
   * @param session the mail session
   * @param dataHandler the datahandler supplying the content to be compressed
   * @param algorithm the compression algorithm to be used
   * 
   * @return the compressed message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createCompressedMessage(Session session, DataHandler dataHandler, AlgorithmID algorithm)
      throws MessagingException {

    String subject = "IAIK-S/MIME: Compressed ["+algorithm.getName()+"]";
    Message msg = createMessage(session, subject.toString());

    CompressedContent compressedContent = new CompressedContent();
    
    if (dataHandler == null) {
      StringBuffer buf = new StringBuffer();
      buf.append("This is the compressed content!\n");
      buf.append("Compression algorithm: "+algorithm.getName());
      buf.append("\n\n");
      compressedContent.setText(buf.toString());
    } else {
      compressedContent.setDataHandler(dataHandler);   
    }    
    
    try {
      compressedContent.setCompressionAlgorithm(algorithm);
    } catch (NoSuchAlgorithmException ex) {
      throw new MessagingException("Compression algorithm not supported: " + ex.getMessage());   
    }   

    msg.setContent(compressedContent, compressedContent.getContentType());
    // let the CompressedContent update some message headers
    compressedContent.setHeaders(msg);

    return msg;
  }

  /**
   * Creates a PKCS#10 certificate request message.
   *
   * @param session the mail session
   * 
   * @return the PKCS#10 certificate request message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createPKCS10Message(Session session)
    throws MessagingException {

    Message msg = createMessage(session, "IAIK-S/MIME: Certificate Request");

    PKCS10Content pc = new PKCS10Content();
    CertificateRequest request = null;
    try {
       request = createCertificateRequest();
    } catch (PKCSException ex) {
       throw new MessagingException(ex.getMessage());
    }
    pc.setCertRequest(request);
    msg.setContent(pc, pc.getContentType());
    // let the PKCS10Content update some message headers
    pc.setHeaders(msg);

    return msg;
  }


  private CertificateRequest createCertificateRequest() throws PKCSException {
    try {
      Name subject = new Name();
          subject.addRDN(ObjectID.commonName, firstName_ + " " + lastName_);
          subject.addRDN(ObjectID.emailAddress, from_);
          CertificateRequest certRequest;
      certRequest = new CertificateRequest(signerCertificate_.getPublicKey(), subject);
          certRequest.sign((AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(), signerPrivateKey_);
          certRequest.verify();
          return certRequest;
        } catch (Exception ex) {
          throw new PKCSException("Cannot create cert request: " + ex.getMessage());
        }

  }
  
  /**
   * Creates a PKCS#10 message where the certificate request is transferred as attachment.
   *
   * @param session the mail session
   * 
   * @return the PKCS#10 certificate request message
   *
   * @throws MessagingException if an error occurs when creating the message
   */
  public Message createPKCS10MultiPartMessage(Session session) throws MessagingException {

    MimeBodyPart mbp1 = new MimeBodyPart();
        mbp1.setText("This is a test where the request message is included in the second part!\n\n");
        // try to test an attachment
        // this demo attaches our homepage
    MimeBodyPart attachment = new MimeBodyPart();
    //use new content types
    SMimeParameters.useNewContentTypes(true);
    PKCS10Content pc = new PKCS10Content();
    CertificateRequest request = null;
    try {
      request = createCertificateRequest();
    } catch (PKCSException ex) {
      throw new MessagingException(ex.getMessage());
    }
    pc.setCertRequest(request);
    DataHandler pkcs10Handler = new DataHandler(pc, pc.getContentType());
    attachment.setDataHandler(pkcs10Handler);
    attachment.setDisposition("attachment");
    attachment.setFileName("smime.p10");
    Multipart mp = new MimeMultipart();
    mp.addBodyPart(mbp1);
    mp.addBodyPart(attachment);

    Message msg = createMessage(session, "IAIK-S/MIME: Certificate Request multipart message");
    msg.setContent(mp, mp.getContentType());
    return msg;
  }
  
  /** 
   * Prints a dump of the given message to System.out.
   *
   * @param msg the message to be dumped to System.out
   *
   * @throws IOException if an I/O error occurs
   */
  static void printMessage(Message msg) throws IOException {
    System.out.println("------------------------------------------------------------------");
    System.out.println("Message dump: \n");
    try {
      msg.writeTo(System.out);
    } catch (MessagingException ex) {
      throw new IOException(ex.getMessage());   
    }    
    System.out.println("\n------------------------------------------------------------------");
  }  
  
  /**
   * The main method.
   */
  public static void main(String[] argv) throws IOException {
     
    DemoSMimeUtil.initDemos();
        (new SMimeV4Demo()).start();
    System.out.println("\nReady!");
    DemoUtil.waitKey();
  }
}