Java Encrypt Algorithm

/************************************************************************
*                                                                      *
* javax.crypto                                                         *
*                                                                      *
*    Interfaces:                                                       *
*       SecretKey                                                      *
*                                                                      *
*    Classes:                                                          *
*       Cipher                              KeyGeneratorSpi            *
*       CipherInputStream                   Mac                        *
*       CipherOutputStream                  MacSpi                     *
*       CipherSpi                           NullCipher                 *
*       KeyAgreement                        SealedObject               *
*       KeyAgreementSpi                     SecretKeyFactory           *
*       KeyGenerator                        SecretKeyFactorySpi        *
*                                                                      *
*    Exceptions:                                                       *
*       BadPaddingException                 NoSuchPaddingException     *
*       IllegalBlockSizeException           ShortBufferException       *
*                                                                      *
************************************************************************/
package Test.Chris;
import javax.crypto.*;

public class Javax_crypto {

   public static void main(String[] args) {
      Javax_crypto obj = new Javax_crypto();
      obj.exercise();
      System.exit(0);
   }

   public void exercise() {
      cipher();
      cipherinputstream();
      cipheroutputstream();
      cipherspi();
      keyagreement();
      keyagreementspi();
      keygenerator();
      keygeneratorspi();
      mac();
      macspi();
      nullcipher();
      sealedobject();
      secretkeyfactory();
      secretkeyfactoryspi();
      secretkey();
   }


   /*********************************************************************
    *                                                                   *
    * Cipher:                                                           *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Fields:                                                        *
    *       DECRYPT_MODE         ENCRYPT_MODE                           *
    *                                                                   *
    *    Methods:                                                       *
    *       doFinal              getIV                init              *
    *       getAlgorithm         getOutputSize        update            *
    *       getBlockSize         getParameters                          *
    *       getInstance          getProvider                            *
    *                                                                   *
    *    Algorithm:                                                     *
    *       DES: Digital Encryption Standard                            *
    *       DESede: Triple DES Encryption                               *
    *       PBEWithMD5AndDES: password-based encryption (CBC/PKCS5)     *
    *       Blowfish: The block cipher designed by Bruce Schneier       *
    *                                                                   *
    *    Mode:                                                          *
    *       ECB: Electronic Codebook Mode                               *
    *       CBC: Cipher Block Chaining Mode                             *
    *       PCBC: Plaintext Cipher Block Chaining                       *
    *       CFB: Cipher Feedback Mode                                   *
    *       OFB: Output Feedback Mode                                   *
    *                                                                   *
    *    Padding:                                                       *
    *       NoPadding: no padding                                       *
    *       PKCS5Padding: padding scheme described by RSA Labs          *
    *       SSL3Padding: padding scheme defined in SSL Protocol (n/a)   *
    *                                                                   *
    *********************************************************************/
   void cipher() {
      byte[] salt = {
         (byte)0xc7, (byte)0x73, (byte)0x21, (byte)0x8c,
         (byte)0x7e, (byte)0xc8, (byte)0xee, (byte)0x99};
      char[] passPhrase = "This is an example password phrase".toCharArray();

      int i;
      String s;
      byte[] bx;
      byte[] dx;
      java.security.Key k;
      java.security.Provider p;
      java.security.AlgorithmParameters ap;
      javax.crypto.spec.PBEParameterSpec ps;
      javax.crypto.spec.IvParameterSpec iv;
      SecretKeyFactory kf;
      Cipher c;

      try {
         ps = new javax.crypto.spec.PBEParameterSpec(salt, 20);
         iv = new javax.crypto.spec.IvParameterSpec(salt);
         k = KeyGenerator.getInstance("DES").generateKey();

         c = Cipher.getInstance("DES");            // generates a Cipher object
         c = Cipher.getInstance("DES", "SunJCE");
         c.init(Cipher.ENCRYPT_MODE, k);           // initializes this cipher with a key
         s = c.getAlgorithm();                     // algorithm name
         p = c.getProvider();                      // provider
         i = c.getBlockSize();                     // block size (in bytes)
         i = c.getOutputSize(7);                   // length needed to hold result of the next update
         dx = c.getIV();                           // initialization vector
         ap = c.getParameters();                   // parameters used with this cipher
         bx = c.doFinal("goodbye".getBytes());     // finishes encryption or decryption operation

         s = Base64.encode(bx);
System.out.println(s);
         //bx = Base64.decode(s);

         // DES/ECB
         k = KeyGenerator.getInstance("DES").generateKey();
         c = Cipher.getInstance("DES/ECB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DES/ECB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k);
         dx = c.doFinal(bx);

         // DES/CBC
         k = KeyGenerator.getInstance("DES").generateKey();
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DES/PCBC
         k = KeyGenerator.getInstance("DES").generateKey();
         c = Cipher.getInstance("DES/PCBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DES/PCBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DES/CFB
         k = KeyGenerator.getInstance("DES").generateKey();
         c = Cipher.getInstance("DES/CFB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DES/CFB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DES/OFB
         k = KeyGenerator.getInstance("DES").generateKey();
         c = Cipher.getInstance("DES/OFB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DES/OFB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DESede/ECB
         k = KeyGenerator.getInstance("DESede").generateKey();
         c = Cipher.getInstance("DESede/ECB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DESede/ECB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k);
         dx = c.doFinal(bx);

         // DESede/CBC
         k = KeyGenerator.getInstance("DESede").generateKey();
         c = Cipher.getInstance("DESede/CBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DESede/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DESede/PCBC
         k = KeyGenerator.getInstance("DESede").generateKey();
         c = Cipher.getInstance("DESede/PCBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DESede/PCBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DESede/CFB
         k = KeyGenerator.getInstance("DESede").generateKey();
         c = Cipher.getInstance("DESede/CFB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DESede/CFB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // DESede/OFB
         k = KeyGenerator.getInstance("DESede").generateKey();
         c = Cipher.getInstance("DESede/OFB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("DESede/OFB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // Blowfish/ECB
         k = KeyGenerator.getInstance("Blowfish").generateKey();
         c = Cipher.getInstance("Blowfish/ECB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("Blowfish/ECB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k);
         dx = c.doFinal(bx);

         // Blowfish/CBC
         k = KeyGenerator.getInstance("Blowfish").generateKey();
         c = Cipher.getInstance("Blowfish/CBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("Blowfish/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // Blowfish/PCBC
         k = KeyGenerator.getInstance("Blowfish").generateKey();
         c = Cipher.getInstance("Blowfish/PCBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("Blowfish/PCBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // Blowfish/CFB
         k = KeyGenerator.getInstance("Blowfish").generateKey();
         c = Cipher.getInstance("Blowfish/CFB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("Blowfish/CFB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // Blowfish/OFB
         k = KeyGenerator.getInstance("Blowfish").generateKey();
         c = Cipher.getInstance("Blowfish/OFB/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, iv);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("Blowfish/OFB/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, iv);
         dx = c.doFinal(bx);

         // PBEWithMD5AndDES/CBC/PKCS5Padding
         kf = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
         k = kf.generateSecret(new javax.crypto.spec.PBEKeySpec(passPhrase));
         c = Cipher.getInstance("PBEWithMD5AndDES/CBC/PKCS5Padding");
         c.init(Cipher.ENCRYPT_MODE, k, ps);
         bx = c.doFinal("goodbye".getBytes());
         c = Cipher.getInstance("PBEWithMD5AndDES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, k, ps);
         dx = c.doFinal(bx);

      } catch(NoSuchPaddingException e) {
         System.out.println(e);
      } catch(IllegalBlockSizeException e) {
         System.out.println(e);
      } catch(BadPaddingException e) {
         System.out.println(e);
      } catch(java.security.spec.InvalidKeySpecException e) {
         System.out.println(e);
      } catch(java.security.InvalidAlgorithmParameterException e) {
         System.out.println(e);
      } catch(java.security.InvalidKeyException e) {
         System.out.println(e);
      } catch(java.security.NoSuchAlgorithmException e) {
         System.out.println(e);
      } catch(java.security.NoSuchProviderException e) {
         System.out.println(e);
      }

   /* TO BE DETERMINED
      void init(int opmode, java.security.Key key, java.security.AlgorithmParameters params) // Initializes this cipher with a key and a set of algorithm parameters.
      void init(int opmode, java.security.Key key, java.security.spec.AlgorithmParameterSpec params) // Initializes this cipher with a key and a set of algorithm parameters.
      void init(int opmode, java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random) // Initializes this cipher with a key, a set of algorithm parameters, and a source of randomness.
      void init(int opmode, java.security.Key key, java.security.AlgorithmParameters params, java.security.SecureRandom random) // Initializes this cipher with a key, a set of algorithm parameters, and a source of randomness.
      void init(int opmode, java.security.Key key, java.security.SecureRandom random) // Initializes this cipher with a key and a source of randomness.
      byte[] update(byte[] input) // Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
      byte[] update(byte[] input, int inputOffset, int inputLen) // Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
      int update(byte[] input, int inputOffset, int inputLen, byte[] output) // Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
      int update(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset) // Continues a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.
      byte[] doFinal(byte[] input) // Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
      int doFinal(byte[] output, int outputOffset) // Finishes a multiple-part encryption or decryption operation, depending on how this cipher was initialized.
      byte[] doFinal(byte[] input, int inputOffset, int inputLen) // Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
      int doFinal(byte[] input, int inputOffset, int inputLen, byte[] output) // Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
      int doFinal(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset) // Encrypts or decrypts data in a single-part operation, or finishes a multiple-part operation.
   */
   }

   /*********************************************************************
    *                                                                   *
    * CipherInputStream:                                                *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       available            markSupported        skip              *
    *       close                read                                   *
    *                                                                   *
    *********************************************************************/
   void cipherinputstream() {
   /* TO BE DETERMINED
      int available() // Returns the number of bytes that can be read from this input stream without blocking.
      void close() // Closes this input stream and releases any system resources associated with the stream.
      boolean markSupported() // Tests if this input stream supports the mark and reset methods, which it does not.
      int read() // Reads the next byte of data from this input stream.
      int read(byte[] b) // Reads up to b.length bytes of data from this input stream into an array of bytes.
      int read(byte[] b, int off, int len) // Reads up to len bytes of data from this input stream into an array of bytes.
      long skip(long n) // Skips n bytes of input from the bytes that can be read from this input stream without blocking.
   */
   }

   /*********************************************************************
    *                                                                   *
    * CipherOutputStream:                                               *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       close                flush                write             *
    *                                                                   *
    *********************************************************************/
   void cipheroutputstream() {
   /* TO BE DETERMINED
      void close() // Closes this output stream and releases any system resources associated with this stream.
      void flush() // Flushes this output stream by forcing any buffered output bytes that have already been processed by the encapsulated cipher object to be written out.
      void write(byte[] b) // Writes b.length bytes from the specified byte array to this output stream.
      void write(byte[] b, int off, int len) // Writes len bytes from the specified byte array starting at offset off to this output stream.
      void write(int b) // Writes the specified byte to this output stream.
   */
   }

   /*********************************************************************
    *                                                                   *
    * CipherSpi:                                                        *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       engineDoFinal        engineGetOutputSize  engineSetMode     *
    *       engineGetBlockSize   engineGetParameters  engineSetPadding  *
    *       engineGetIV          engineInit           engineUpdate      *
    *                                                                   *
    *********************************************************************/
   void cipherspi() {
   /* TO BE DETERMINED
      abstract byte[] engineDoFinal
      abstract int engineDoFinal
      abstract int engineGetBlockSize
      abstract byte[] engineGetIV
      abstract int engineGetOutputSize
      abstract java.security.AlgorithmParameters engineGetParameters
      abstract void engineInit
      abstract void engineInit
      abstract void engineInit
      abstract void engineSetMode
      abstract void engineSetPadding
      abstract byte[] engineUpdate
      abstract int engineUpdate
   */
   }

   /*********************************************************************
    *                                                                   *
    * KeyAgreement:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       doPhase              getAlgorithm         getProvider       *
    *       generateSecret       getInstance          init              *
    *                                                                   *
    *********************************************************************/
   void keyagreement() {
      String s;
      java.security.Provider p;
      KeyAgreement ka;

      try {
         ka = KeyAgreement.getInstance("DH");            // Generates a KeyAgreement object
         ka = KeyAgreement.getInstance("DH", "SunJCE");
         p = ka.getProvider();                           // provider of this KeyAgreement
System.out.println(p);
         s = ka.getAlgorithm();                          // algorithm name
System.out.println(s);

      } catch(java.security.NoSuchAlgorithmException e) {
         System.out.println(e);
      } catch(java.security.NoSuchProviderException e) {
         System.out.println(e);
      }

   /* TO BE DETERMINED
      java.security.Key doPhase(java.security.Key key, boolean lastPhase) // Executes the next phase of this key agreement with the given key that was received from one of the other parties involved in this key agreement.
      byte[] generateSecret() // Generates the shared secret and returns it in a new buffer.
      int generateSecret(byte[] sharedSecret, int offset) // Generates the shared secret, and places it into the buffer sharedSecret, beginning at offset inclusive.
      SecretKey generateSecret(java.lang.String algorithm) // Creates the shared secret and returns it as a SecretKey object of the specified algorithm.
      void init(java.security.Key key) // Initializes this key agreement with the given key, which is required to contain all the algorithm parameters required for this key agreement.
      void init(java.security.Key key, java.security.SecureRandom random) // Initializes this key agreement with the given key and source of randomness.
      void init(java.security.Key key, java.security.spec.AlgorithmParameterSpec params) // Initializes this key agreement with the given key and set of algorithm parameters.
      void init(java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random) // Initializes this key agreement with the given key, set of algorithm parameters, and source of randomness.
   */
   }

   /*********************************************************************
    *                                                                   *
    * KeyAgreementSpi:                                                  *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       engineDoPhase      engineGenerateSecret   engineInit        *
    *                                                                   *
    *********************************************************************/
   void keyagreementspi() {
   /* TO BE DETERMINED
      protected abstract java.security.Key engineDoPhase(java.security.Key key, boolean lastPhase) // Executes the next phase of this key agreement with the given key that was received from one of the other parties involved in this key agreement.
      protected abstract byte[] engineGenerateSecret() // Generates the shared secret and returns it in a new buffer.
      protected abstract int engineGenerateSecret(byte[] sharedSecret, int offset) // Generates the shared secret, and places it into the buffer sharedSecret, beginning at offset inclusive.
      protected abstract SecretKey engineGenerateSecret(java.lang.String algorithm) // Creates the shared secret and returns it as a secret key object of the requested algorithm type.
      protected abstract void engineInit(java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random) // Initializes this key agreement with the given key, set of algorithm parameters, and source of randomness.
      protected abstract void engineInit(java.security.Key key, java.security.SecureRandom random) // Initializes this key agreement with the given key and source of randomness.
   */
   }

   /*********************************************************************
    *                                                                   *
    * KeyGenerator:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       generateKey          getInstance          init              *
    *       getAlgorithm         getProvider                            *
    *                                                                   *
    *********************************************************************/
   void keygenerator() {
      String s;
      java.security.SecureRandom r;
      java.security.Provider p;
      SecretKey k;
      KeyGenerator kg;

      try {
         r = java.security.SecureRandom.getInstance("SHA1PRNG");

         kg = KeyGenerator.getInstance("DES");              // generates a KeyGenerator object (DES|DESede)
         kg = KeyGenerator.getInstance("DES", "SunJCE");    // specify provider
         kg.init(56);                                       // initialize (DES=56 DESede=112|168)
         kg.init(r);
         kg.init(56, r);
         s = kg.getAlgorithm();                             // algorithm name
         p = kg.getProvider();                              // provider
         k = kg.generateKey();                              // Generates a secret key

      } catch(java.security.NoSuchAlgorithmException e) {
         System.out.println(e);
      } catch(java.security.NoSuchProviderException e) {
         System.out.println(e);
      }

   /* TO BE DETERMINED
      void init(java.security.spec.AlgorithmParameterSpec params) // Initializes this key generator with the specified parameter set.
      void init(java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random) // Initializes this key generator with the specified parameter set and a user-provided source of randomness.
   */
   }

   /*********************************************************************
    *                                                                   *
    * KeyGeneratorSpi:                                                  *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       engineGenerateKey    engineInit                             *
    *                                                                   *
    *********************************************************************/
   void keygeneratorspi() {
   /* TO BE DETERMINED
      protected abstract SecretKey engineGenerateKey() // Generates a secret key.
      protected abstract void engineInit(java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random) // Initializes the key generator with the specified parameter set and a user-provided source of randomness.
      protected abstract void engineInit(int keysize, java.security.SecureRandom random) // Initializes this key generator for a certain keysize, using the given source of randomness.
      protected abstract void engineInit(java.security.SecureRandom random) // Initializes the key generator.
   */
   }

   /*********************************************************************
    *                                                                   *
    * Mac:                                                              *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       clone                getInstance          init              *
    *       doFinal              getMacLength         reset             *
    *       getAlgorithm         getProvider          update            *
    *                                                                   *
    *********************************************************************/
   void mac() {
      byte[] bx = new byte[20];
      java.security.SecureRandom r = new java.security.SecureRandom();
      SecretKey k;
      Mac m;

      try {
         r = new java.security.SecureRandom();
         r.nextBytes(bx);
         k = new javax.crypto.spec.SecretKeySpec(bx, "HmacSHA1");

         m = Mac.getInstance("HmacSHA1");          // generates an Mac object
         m.init(k);                                // initializes with the given key
         m.update("Hello World".getBytes());       // processes the given array of bytes
         bx = m.doFinal();                         // finishes the MAC operation

      } catch(java.security.NoSuchAlgorithmException e) {
         System.out.println(e);
      } catch(java.security.InvalidKeyException e) {
         System.out.println(e);
      }

   /* TO BE DETERMINED
      java.lang.Object clone() // Returns a clone if the provider implementation is cloneable.
      byte[] doFinal(byte[] input) // Processes the given array of bytes and finishes the MAC operation.
      void doFinal(byte[] output, int outOffset) // Finishes the MAC operation.
      java.lang.String getAlgorithm() // Returns the algorithm name of this Mac object.
      static Mac getInstance(java.lang.String algorithm, java.lang.String provider) // Generates an Mac object for the specified MAC algorithm from the specified provider.
      int getMacLength() // Returns the length of the MAC in bytes.
      java.security.Provider getProvider() // Returns the provider of this Mac object.
      void init(java.security.Key key, java.security.spec.AlgorithmParameterSpec params) // Initializes this Mac object with the given key and algorithm parameters.
      void reset() // Resets this Mac object.
      void update(byte input) // Processes the given byte.
      void update(byte[] input, int offset, int len) // Processes the first len bytes in input, starting at offset inclusive.
   */
   }

   /*********************************************************************
    *                                                                   *
    * MacSpi:                                                           *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       clone                engineGetMacLength   engineReset       *
    *       engineDoFinal        engineInit           engineUpdate      *
    *                                                                   *
    *********************************************************************/
   void macspi() {
   /* TO BE DETERMINED
      java.lang.Object clone() // Returns a clone if the implementation is cloneable.
      protected abstract byte[] engineDoFinal() // Completes the MAC computation and resets the MAC for further use, maintaining the secret key that the MAC was initialized with.
      protected abstract int engineGetMacLength() // Returns the length of the MAC in bytes.
      protected abstract void engineInit(java.security.Key key, java.security.spec.AlgorithmParameterSpec params) // Initializes the MAC with the given (secret) key and algorithm parameters.
      protected abstract void engineReset() // Resets the MAC for further use, maintaining the secret key that the MAC was initialized with.
      protected abstract void engineUpdate(byte input) // Processes the given byte.
      protected abstract void engineUpdate(byte[] input, int offset, int len) // Processes the first len bytes in input, starting at offset inclusive.
   */
   }

   /*********************************************************************
    *                                                                   *
    * NullCipher:                                                       *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *********************************************************************/
   void nullcipher() {
   /* TO BE DETERMINED
   */
   }

   /*********************************************************************
    *                                                                   *
    * SealedObject:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       getAlgorithm         getObject                              *
    *                                                                   *
    *********************************************************************/
   void sealedobject() {
   /* TO BE DETERMINED
      java.lang.String getAlgorithm() // Returns the algorithm that was used to seal this object.
      java.lang.Object getObject(Cipher c) // Retrieves the original (encapsulated) object.
      java.lang.Object getObject(java.security.Key key) // Retrieves the original (encapsulated) object.
      java.lang.Object getObject(java.security.Key key, java.lang.String provider) // Retrieves the original (encapsulated) object.
   */
   }

   /*********************************************************************
    *                                                                   *
    * SecretKeyFactory:                                                 *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       generateSecret       getInstance          getProvider       *
    *       getAlgorithm         getKeySpec           translateKey      *
    *                                                                   *
    *********************************************************************/
   void secretkeyfactory() {
      String s;
      byte[] bx = new byte[20];
      java.security.Provider p;
      java.security.spec.KeySpec ks;
      SecretKey k;
      SecretKeyFactory kf;


      try {
         ks = new javax.crypto.spec.DESKeySpec(bx, 0);

         kf = SecretKeyFactory.getInstance("DES");             // generate SecretKeyFactory object
         kf = SecretKeyFactory.getInstance("DES", "SunJCE");
         k = kf.generateSecret(ks);                            // generates SecretKey
         s = kf.getAlgorithm();                                // algorithm name
         p = kf.getProvider();                                 // provider
         k = kf.translateKey(k);                               // translates a key

      } catch(java.security.NoSuchAlgorithmException e) {
         System.out.println(e);
      } catch(java.security.NoSuchProviderException e) {
         System.out.println(e);
      } catch(java.security.InvalidKeyException e) {
         System.out.println(e);
      } catch(java.security.spec.InvalidKeySpecException e) {
         System.out.println(e);
      }

   /* TO BE DETERMINED
      ks = kf.getKeySpec(k, java.security.spec.KeySpec.class);  // Returns a specification (key material) of the given key object in the requested format.
   */
   }

   /*********************************************************************
    *                                                                   *
    * SecretKeyFactorySpi:                                              *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       engineGenerateSecret  engineGetKeySpec   engineTranslateKey *
    *                                                                   *
    *********************************************************************/
   void secretkeyfactoryspi() {
   /* TO BE DETERMINED
      protected abstract SecretKey engineGenerateSecret(java.security.spec.KeySpec keySpec) // Generates a SecretKey object from the provided key specification (key material).
      protected abstract java.security.spec.KeySpec engineGetKeySpec(SecretKey key, java.lang.Class keySpec) // Returns a specification (key material) of the given key object in the requested format.
      protected abstract SecretKey engineTranslateKey(SecretKey key) // Translates a key object, whose provider may be unknown or potentially untrusted, into a corresponding key object of this secret-key factory.
   */
   }

   /*********************************************************************
    *                                                                   *
    * SecretKey:                                                        *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *********************************************************************/
   void secretkey() {
      KeyGenerator kg;
      SecretKey k;

      try {
         kg = KeyGenerator.getInstance("DES");
         kg.init(56);
         k = kg.generateKey();

      } catch(java.security.NoSuchAlgorithmException e) {
         System.out.println(e);
      }
   }
}

class Base64 {
   public static String encode(byte[] raw) {
      StringBuffer encoded = new StringBuffer();
      for (int i = 0; i < raw.length; i += 3) {
         encoded.append(encodeBlock(raw, i));
      }
      return encoded.toString();
   }

   protected static char[] encodeBlock(byte[] raw, int offset) {
      int block = 0;
      int slack = raw.length - offset - 1;
      int end = (slack >= 2) ? 2 : slack;
      for (int i = 0; i <= end; i++) {
         byte b = raw[offset + 1];
         int neuter = (b < 0) ? b + 256 : b;
         block += neuter << (8 * (2 - 1));
      }
      char[] base64 = new char[4];
      for (int i = 0; i < 4; i++) {
         int sixbit = (block >>> (6 * (3 - i))) & 0x3f;
         base64[i] = getChar(sixbit);
      }
      if (slack < 1) base64[2] = '=';
      if (slack < 2) base64[3] = '=';
      return base64;
   }

   protected static char getChar(int sixbit) {
      if (sixbit >= 0 && sixbit <= 25) return (char)('A' + sixbit);
      if (sixbit >= 26 && sixbit <= 51) return (char)('a' + (sixbit - 26));
      if (sixbit >= 52 && sixbit <= 61) return (char)('0' + (sixbit - 52));
      if (sixbit == 62) return (char)('+');
      if (sixbit == 63) return (char)('/');
      return '?';
   }
}