/*
 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.security.pkcs11;

import java.io.*;
import java.security.*;
import sun.security.pkcs11.wrapper.*;

SecureRandom implementation class. Some tokens support only C_GenerateRandom() and not C_SeedRandom(). In order not to lose an application specified seed, we create a SHA1PRNG that we mix with in that case. Note that since SecureRandom is thread safe, we only need one instance per PKCS#11 token instance. It is created on demand and cached in the SunPKCS11 class. Also note that we obtain the PKCS#11 session on demand, no need to tie one up.
Author: Andreas Sterbenz
Since: 1.5
/** * SecureRandom implementation class. Some tokens support only * C_GenerateRandom() and not C_SeedRandom(). In order not to lose an * application specified seed, we create a SHA1PRNG that we mix with in that * case. * * Note that since SecureRandom is thread safe, we only need one * instance per PKCS#11 token instance. It is created on demand and cached * in the SunPKCS11 class. * * Also note that we obtain the PKCS#11 session on demand, no need to tie one * up. * * @author Andreas Sterbenz * @since 1.5 */
final class P11SecureRandom extends SecureRandomSpi { private static final long serialVersionUID = -8939510236124553291L; // token instance private final Token token; // PRNG for mixing, non-null if active (i.e. setSeed() has been called) private volatile SecureRandom mixRandom; // buffer, if mixing is used private byte[] mixBuffer; // bytes remaining in mixBuffer, if mixing is used private int buffered; /* * we buffer data internally for efficiency but limit the lifetime * to avoid using stale bits. */ // lifetime in ms, currently 100 ms (0.1 s) private static final long MAX_IBUFFER_TIME = 100; // size of the internal buffer private static final int IBUFFER_SIZE = 32; // internal buffer for the random bits private transient byte[] iBuffer = new byte[IBUFFER_SIZE]; // number of bytes remain in iBuffer private transient int ibuffered = 0; // time that data was read into iBuffer private transient long lastRead = 0L; P11SecureRandom(Token token) { this.token = token; } // see JCA spec @Override protected synchronized void engineSetSeed(byte[] seed) { if (seed == null) { throw new NullPointerException("seed must not be null"); } Session session = null; try { session = token.getOpSession(); token.p11.C_SeedRandom(session.id(), seed); } catch (PKCS11Exception e) { // cannot set seed // let a SHA1PRNG use that seed instead SecureRandom random = mixRandom; if (random != null) { random.setSeed(seed); } else { try { mixBuffer = new byte[20]; random = SecureRandom.getInstance("SHA1PRNG"); // initialize object before assigning to class field random.setSeed(seed); mixRandom = random; } catch (NoSuchAlgorithmException ee) { throw new ProviderException(ee); } } } finally { token.releaseSession(session); } } // see JCA spec @Override protected void engineNextBytes(byte[] bytes) { if ((bytes == null) || (bytes.length == 0)) { return; } if (bytes.length <= IBUFFER_SIZE) { int ofs = 0; synchronized (iBuffer) { while (ofs < bytes.length) { long time = System.currentTimeMillis(); // refill the internal buffer if empty or stale if ((ibuffered == 0) || !(time - lastRead < MAX_IBUFFER_TIME)) { lastRead = time; implNextBytes(iBuffer); ibuffered = IBUFFER_SIZE; } // copy the buffered bytes into 'bytes' while ((ofs < bytes.length) && (ibuffered > 0)) { bytes[ofs++] = iBuffer[IBUFFER_SIZE - ibuffered--]; } } } } else { // avoid using the buffer - just fill bytes directly implNextBytes(bytes); } } // see JCA spec @Override protected byte[] engineGenerateSeed(int numBytes) { byte[] b = new byte[numBytes]; engineNextBytes(b); return b; } private void mix(byte[] b) { SecureRandom random = mixRandom; if (random == null) { // avoid mixing if setSeed() has never been called return; } synchronized (this) { int ofs = 0; int len = b.length; while (len-- > 0) { if (buffered == 0) { random.nextBytes(mixBuffer); buffered = mixBuffer.length; } b[ofs++] ^= mixBuffer[mixBuffer.length - buffered]; buffered--; } } } // fill up the specified buffer with random bytes, and mix them private void implNextBytes(byte[] bytes) { Session session = null; try { session = token.getOpSession(); token.p11.C_GenerateRandom(session.id(), bytes); mix(bytes); } catch (PKCS11Exception e) { throw new ProviderException("nextBytes() failed", e); } finally { token.releaseSession(session); } } private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); // assign default values to non-null transient fields iBuffer = new byte[IBUFFER_SIZE]; ibuffered = 0; lastRead = 0L; } }