package gnu.crypto.jce.prng;

// ----------------------------------------------------------------------------
// $Id: UMacRandomSpi.java,v 1.3 2005/10/06 04:24:15 rsdio Exp $
//
// Copyright (C) 2001, 2002, Free Software Foundation, Inc.
//
// This file is part of GNU Crypto.
//
// GNU Crypto is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// GNU Crypto is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; see the file COPYING.  If not, write to the
//
//    Free Software Foundation Inc.,
//    51 Franklin Street, Fifth Floor,
//    Boston, MA 02110-1301
//    USA
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library.  Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
//
// As a special exception, the copyright holders of this library give
// you permission to link this library with independent modules to
// produce an executable, regardless of the license terms of these
// independent modules, and to copy and distribute the resulting
// executable under terms of your choice, provided that you also meet,
// for each linked independent module, the terms and conditions of the
// license of that module.  An independent module is a module which is
// not derived from or based on this library.  If you modify this
// library, you may extend this exception to your version of the
// library, but you are not obligated to do so.  If you do not wish to
// do so, delete this exception statement from your version.
// ----------------------------------------------------------------------------

import gnu.crypto.Registry;
import gnu.crypto.cipher.IBlockCipher;
import gnu.crypto.prng.LimitReachedException;
import gnu.crypto.prng.UMacGenerator;

import java.io.PrintWriter;
import java.security.SecureRandomSpi;
import java.util.HashMap;
import java.util.Random;

/**
 * <p>An <em>Adapter</em> class around {@link UMacGenerator} to allow using this
 * algorithm as a JCE {@link java.security.SecureRandom}.</p>
 *
 * @version $Revision: 1.3 $
 */
public class UMacRandomSpi extends SecureRandomSpi {

   // Debugging methods and variables
   // -------------------------------------------------------------------------

   private static final String NAME = "UMacRandomSpi";
   private static final boolean DEBUG = false;
   private static final PrintWriter err = new PrintWriter(System.out, true);
   private static void debug(String s) {
      err.println(">>> "+NAME+": "+s);
   }

   // Constants and variables
   // -------------------------------------------------------------------------

   /** Class-wide prng to generate random material for the underlying prng.*/
   private static final UMacGenerator prng; // blank final
   static {
      prng = new UMacGenerator();
      resetLocalPRNG();
   }

   // error messages
   private static final String MSG =
         "Exception while setting up a "+Registry.UMAC_PRNG+" SPI: ";
   private static final String RETRY = "Retry...";

   /** Our underlying prng instance. */
   private UMacGenerator adaptee = new UMacGenerator();

   // Constructor(s)
   // -------------------------------------------------------------------------

   // default 0-arguments constructor

   // Class methods
   // -------------------------------------------------------------------------

   private static void resetLocalPRNG() {
      HashMap attributes = new HashMap();
      attributes.put(UMacGenerator.CIPHER, Registry.AES_CIPHER);
      byte[] key = new byte[128 / 8]; // AES default key size
      Random rand = new Random(System.currentTimeMillis());
      rand.nextBytes(key);
      attributes.put(IBlockCipher.KEY_MATERIAL, key);
      int index = rand.nextInt() & 0xFF;
      attributes.put(UMacGenerator.INDEX, new Integer(index));

      prng.setup(attributes);
   }

   // Instance methods
   // -------------------------------------------------------------------------

   // java.security.SecureRandomSpi interface implementation ------------------

   public byte[] engineGenerateSeed(int numBytes) {
      if (numBytes < 1) {
         return new byte[0];
      }
      byte[] result = new byte[numBytes];
      this.engineNextBytes(result);
      return result;
   }

   public void engineNextBytes(byte[] bytes) {
      if (!adaptee.isInitialised()) {
         this.engineSetSeed(new byte[0]);
      }

      while (true) {
         try {
            adaptee.nextBytes(bytes, 0, bytes.length);
            break;
         } catch (LimitReachedException x) { // reseed the generator
            resetLocalPRNG();
         }
      }
   }

   public void engineSetSeed(byte[] seed) {
      // compute the total number of random bytes required to setup adaptee
      int materialLength = 0;
      materialLength += 16; // key material size
      materialLength++; // index size
      byte[] material = new byte[materialLength];

      // use as much as possible bytes from the seed
      int materialOffset = 0;
      int materialLeft = material.length;
      if (seed.length > 0) { // copy some bytes into key and update indices
         int lenToCopy = Math.min(materialLength, seed.length);
         System.arraycopy(seed, 0, material, 0, lenToCopy);
         materialOffset += lenToCopy;
         materialLeft -= lenToCopy;
      }
      if (materialOffset > 0) { // generate the rest
         while (true) {
            try {
               prng.nextBytes(material, materialOffset, materialLeft);
               break;
            } catch (IllegalStateException x) { // should not happen
               throw new InternalError(MSG + String.valueOf(x));
            } catch (LimitReachedException x) {
               if (DEBUG) {
                  debug(MSG + String.valueOf(x));
                  debug(RETRY);
               }
            }
         }
      }

      // setup the underlying adaptee instance
      HashMap attributes = new HashMap();

      // use AES cipher with 128-bit block size
      attributes.put(UMacGenerator.CIPHER, Registry.AES_CIPHER);
      // specify the key
      byte[] key = new byte[16];
      System.arraycopy(material, 0, key, 0, 16);
      attributes.put(IBlockCipher.KEY_MATERIAL, key);
      // use a 1-byte index
      attributes.put(UMacGenerator.INDEX, new Integer(material[16] & 0xFF));

      adaptee.init(attributes);
   }
}
