Save This Page
Home » openjdk-7 » java » security » [javadoc | source]
    1   /* VMSecureRandom.java -- random seed generator.
    2      Copyright (C) 2006  Free Software Foundation, Inc.
    3   
    4   This file is a part of GNU Classpath.
    5   
    6   GNU Classpath is free software; you can redistribute it and/or modify
    7   it under the terms of the GNU General Public License as published by
    8   the Free Software Foundation; either version 2 of the License, or (at
    9   your option) any later version.
   10   
   11   GNU Classpath is distributed in the hope that it will be useful, but
   12   WITHOUT ANY WARRANTY; without even the implied warranty of
   13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14   General Public License for more details.
   15   
   16   You should have received a copy of the GNU General Public License
   17   along with GNU Classpath; if not, write to the Free Software
   18   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
   19   USA
   20   
   21   Linking this library statically or dynamically with other modules is
   22   making a combined work based on this library.  Thus, the terms and
   23   conditions of the GNU General Public License cover the whole
   24   combination.
   25   
   26   As a special exception, the copyright holders of this library give you
   27   permission to link this library with independent modules to produce an
   28   executable, regardless of the license terms of these independent
   29   modules, and to copy and distribute the resulting executable under
   30   terms of your choice, provided that you also meet, for each linked
   31   independent module, the terms and conditions of the license of that
   32   module.  An independent module is a module which is not derived from
   33   or based on this library.  If you modify this library, you may extend
   34   this exception to your version of the library, but you are not
   35   obligated to do so.  If you do not wish to do so, delete this
   36   exception statement from your version.  */
   37   
   38   
   39   package java.security;
   40   
   41   import gnu.classpath.SystemProperties;
   42   import gnu.java.security.action.GetSecurityPropertyAction;
   43   
   44   import java.net.URL;
   45   
   46   /**
   47    * VM-specific methods for generating real (or almost real) random
   48    * seeds. VM implementors should write a version of this class that
   49    * reads random bytes from some system source.
   50    *
   51    * <p>The default implementation of this class runs eight threads that
   52    * increment counters in a tight loop, and XORs each counter to
   53    * produce one byte of seed data. This is not very efficient, and is
   54    * not guaranteed to be random (the thread scheduler is probably
   55    * deterministic, after all). If possible, VM implementors should
   56    * reimplement this class so it obtains a random seed from a system
   57    * facility, such as a system entropy gathering device or hardware
   58    * random number generator.
   59    */
   60   final class VMSecureRandom
   61   {
   62   
   63     /**
   64      * Generate a random seed. Implementations are free to generate
   65      * fewer random bytes than are requested, and leave the remaining
   66      * bytes of the destination buffer as zeros. Implementations SHOULD,
   67      * however, make a best-effort attempt to satisfy the request.
   68      *
   69      * @param buffer The destination buffer.
   70      * @param offset The offset in the buffer to start putting bytes.
   71      * @param length The number of random bytes to generate.
   72      */
   73     static int generateSeed(byte[] buffer, int offset, int length)
   74     {
   75       if (length < 0)
   76         throw new IllegalArgumentException("length must be nonnegative");
   77       if (offset < 0 || offset + length > buffer.length)
   78         throw new IndexOutOfBoundsException();
   79   
   80       Spinner[] spinners = new Spinner[8];
   81       int n = 0x1;
   82       for (int i = 0; i < spinners.length; i++)
   83         {
   84           spinners[i] = new Spinner((byte) n);
   85           Thread t = new Thread(spinners[i]);
   86           t.start();
   87           n <<= 1;
   88         }
   89   
   90       // Wait until at least one spinner has started.
   91       while (!(spinners[0].running || spinners[1].running || spinners[2].running
   92                || spinners[3].running || spinners[4].running || spinners[5].running
   93                || spinners[6].running || spinners[7].running))
   94         {
   95           Thread.yield();
   96         }
   97   
   98       for (int i = offset; i < length; i++)
   99         {
  100           buffer[i] = (byte) (spinners[0].value ^ spinners[1].value ^ spinners[2].value
  101                               ^ spinners[3].value ^ spinners[4].value ^ spinners[5].value
  102                               ^ spinners[6].value ^ spinners[7].value);
  103           Thread.yield();
  104         }
  105   
  106       for (int i = 0; i < spinners.length; i++)
  107         spinners[i].stop();
  108   
  109       return length;
  110     }
  111   
  112     static class Spinner implements Runnable
  113     {
  114       volatile byte value;
  115       volatile boolean running;
  116   
  117       Spinner(final byte initial)
  118       {
  119         value = initial;
  120       }
  121   
  122       public void run()
  123       {
  124         running = true;
  125         while (running)
  126           value++;
  127       }
  128   
  129       private void stop()
  130       {
  131         running = false;
  132       }
  133     }
  134   }

Save This Page
Home » openjdk-7 » java » security » [javadoc | source]