java.security.ProviderException Java Examples

private Session openSession() throws PKCS11Exception {
    if ((maxSessions != Integer.MAX_VALUE) &&
            (activeSessions.get() >= maxSessions)) {
        throw new ProviderException("No more sessions available");
    }

    long id = token.p11.C_OpenSession
                (token.provider.slotID, openSessionFlags, null, null);
    Session session = new Session(token, id);
    activeSessions.incrementAndGet();
    if (debug != null) {
        synchronized(maxActiveSessionsLock) {
            if (activeSessions.get() > maxActiveSessions) {
                maxActiveSessions = activeSessions.get();
                if (maxActiveSessions % 10 == 0) {
                    System.out.println("Open sessions: " + maxActiveSessions);
                }
            }
        }
    }
    return session;
}
 

private Session openSession() throws PKCS11Exception {
    if ((maxSessions != Integer.MAX_VALUE) &&
            (activeSessions.get() >= maxSessions)) {
        throw new ProviderException("No more sessions available");
    }

    long id = token.p11.C_OpenSession
                (token.provider.slotID, openSessionFlags, null, null);
    Session session = new Session(token, id);
    activeSessions.incrementAndGet();
    if (debug != null) {
        synchronized(maxActiveSessionsLock) {
            if (activeSessions.get() > maxActiveSessions) {
                maxActiveSessions = activeSessions.get();
                if (maxActiveSessions % 10 == 0) {
                    System.out.println("Open sessions: " + maxActiveSessions);
                }
            }
        }
    }
    return session;
}
 

/**
 * Performs decryption operation.
 *
 * <p>The input cipher text <code>cipher</code>, starting at
 * <code>cipherOffset</code> and ending at
 * <code>(cipherOffset + cipherLen - 1)</code>, is decrypted.
 * The result is stored in <code>plain</code>, starting at
 * <code>plainOffset</code>.
 *
 * @param cipher the buffer with the input data to be decrypted
 * @param cipherOffset the offset in <code>cipherOffset</code>
 * @param cipherLen the length of the input data
 * @param plain the buffer for the result
 * @param plainOffset the offset in <code>plain</code>
 * @exception ProviderException if <code>cipherLen</code> is not
 * a multiple of the block size
 * @return the length of the decrypted data
 */
int decrypt(byte[] cipher, int cipherOffset, int cipherLen,
            byte[] plain, int plainOffset)
{
    if ((cipherLen % blockSize) != 0) {
         throw new ProviderException("Internal error in input buffering");
    }
    int i;
    int endIndex = cipherOffset + cipherLen;

    for (; cipherOffset < endIndex;
         plainOffset += blockSize, cipherOffset += blockSize) {
        embeddedCipher.decryptBlock(cipher, cipherOffset,
                               plain, plainOffset);
        for (i = 0; i < blockSize; i++) {
            plain[i + plainOffset] ^= k[i];
        }
        for (i = 0; i < blockSize; i++) {
            k[i] = (byte)(plain[i + plainOffset] ^ cipher[i + cipherOffset]);
        }
    }
    return cipherLen;
}
 

private Session openSession() throws PKCS11Exception {
    if ((maxSessions != Integer.MAX_VALUE) &&
            (activeSessions.get() >= maxSessions)) {
        throw new ProviderException("No more sessions available");
    }

    long id = token.p11.C_OpenSession
                (token.provider.slotID, openSessionFlags, null, null);
    Session session = new Session(token, id);
    activeSessions.incrementAndGet();
    if (debug != null) {
        synchronized(maxActiveSessionsLock) {
            if (activeSessions.get() > maxActiveSessions) {
                maxActiveSessions = activeSessions.get();
                if (maxActiveSessions % 10 == 0) {
                    System.out.println("Open sessions: " + maxActiveSessions);
                }
            }
        }
    }
    return session;
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset) {
    if ((plainLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }

    int nShift = blockSize - numBytes;
    int loopCount = plainLen / numBytes;

    for (; loopCount > 0 ;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        for (int i = 0; i < numBytes; i++) {
            register[nShift + i] = cipher[i + cipherOffset] =
                    (byte)(k[i] ^ plain[i + plainOffset]);
        }
    }
    return plainLen;
}
 

/**
 * Performs decryption operation.
 *
 * <p>The input cipher text <code>cipher</code>, starting at
 * <code>cipherOffset</code> and ending at
 * <code>(cipherOffset + cipherLen - 1)</code>, is decrypted.
 * The result is stored in <code>plain</code>, starting at
 * <code>plainOffset</code>.
 *
 * @param cipher the buffer with the input data to be decrypted
 * @param cipherOffset the offset in <code>cipherOffset</code>
 * @param cipherLen the length of the input data
 * @param plain the buffer for the result
 * @param plainOffset the offset in <code>plain</code>
 * @exception ProviderException if <code>cipherLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the decrypted data
 */
int decrypt(byte[] cipher, int cipherOffset, int cipherLen,
            byte[] plain, int plainOffset) {
    if ((cipherLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }

    int nShift = blockSize - numBytes;
    int loopCount = cipherLen / numBytes;

    for (; loopCount > 0;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        for (int i = 0; i < numBytes; i++) {
            register[i + nShift] = cipher[i + cipherOffset];
            plain[i + plainOffset]
                = (byte)(cipher[i + cipherOffset] ^ k[i]);
        }
    }
    return cipherLen;
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>len</code> is not
 * a multiple of the block size
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset)
{
    if (plainLen <= 0) {
        return plainLen;
    }
    if ((plainLen % blockSize) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }
    int endIndex = plainOffset + plainLen;

    for (; plainOffset < endIndex;
         plainOffset+=blockSize, cipherOffset += blockSize) {
        for (int i = 0; i < blockSize; i++) {
            k[i] = (byte)(plain[i + plainOffset] ^ r[i]);
        }
        embeddedCipher.encryptBlock(k, 0, cipher, cipherOffset);
        System.arraycopy(cipher, cipherOffset, r, 0, blockSize);
    }
    return plainLen;
}
 

/**
 * Performs decryption operation.
 *
 * <p>The input cipher text <code>cipher</code>, starting at
 * <code>cipherOffset</code> and ending at
 * <code>(cipherOffset + cipherLen - 1)</code>, is decrypted.
 * The result is stored in <code>plain</code>, starting at
 * <code>plainOffset</code>.
 *
 * @param cipher the buffer with the input data to be decrypted
 * @param cipherOffset the offset in <code>cipherOffset</code>
 * @param cipherLen the length of the input data
 * @param plain the buffer for the result
 * @param plainOffset the offset in <code>plain</code>
 * @exception ProviderException if <code>cipherLen</code> is not
 * a multiple of the block size
 * @return the length of the decrypted data
 */
int decrypt(byte[] cipher, int cipherOffset, int cipherLen,
            byte[] plain, int plainOffset)
{
    if ((cipherLen % blockSize) != 0) {
         throw new ProviderException("Internal error in input buffering");
    }
    int i;
    int endIndex = cipherOffset + cipherLen;

    for (; cipherOffset < endIndex;
         plainOffset += blockSize, cipherOffset += blockSize) {
        embeddedCipher.decryptBlock(cipher, cipherOffset,
                               plain, plainOffset);
        for (i = 0; i < blockSize; i++) {
            plain[i + plainOffset] ^= k[i];
        }
        for (i = 0; i < blockSize; i++) {
            k[i] = (byte)(plain[i + plainOffset] ^ cipher[i + cipherOffset]);
        }
    }
    return cipherLen;
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset) {

    if ((plainLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }
    int nShift = blockSize - numBytes;
    int loopCount = plainLen / numBytes;

    for (; loopCount > 0;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        for (int i = 0; i < numBytes; i++) {
            cipher[i + cipherOffset] =
                (byte)(k[i] ^ plain[i + plainOffset]);
        }
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        System.arraycopy(k, 0, register, nShift, numBytes);
    }
    return plainLen;
}
 

static void test(String algo, Provider provider, boolean priv,
        Consumer<Key> method) throws Exception {
    KeyPairGenerator generator;
    try {
        generator = KeyPairGenerator.getInstance(algo, provider);
    } catch (NoSuchAlgorithmException nsae) {
        return;
    }

    System.out.println("Checking " + provider.getName() + ", " + algo);

    KeyPair pair = generator.generateKeyPair();
    Key key = priv ? pair.getPrivate() : pair.getPublic();

    pair = null;
    for (int i = 0; i < 32; ++i) {
        System.gc();
    }

    try {
        method.accept(key);
    } catch (ProviderException pe) {
        failures++;
    }
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the block size
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset)
{
    if ((plainLen % blockSize) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }
    int i;
    int endIndex = plainOffset + plainLen;

    for (; plainOffset < endIndex;
         plainOffset += blockSize, cipherOffset += blockSize) {
        for (i = 0; i < blockSize; i++) {
            k[i] ^= plain[i + plainOffset];
        }
        embeddedCipher.encryptBlock(k, 0, cipher, cipherOffset);
        for (i = 0; i < blockSize; i++) {
            k[i] = (byte)(plain[i + plainOffset] ^ cipher[i + cipherOffset]);
        }
    }
    return plainLen;
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset) {

    if ((plainLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }
    int nShift = blockSize - numBytes;
    int loopCount = plainLen / numBytes;

    for (; loopCount > 0;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        for (int i = 0; i < numBytes; i++) {
            cipher[i + cipherOffset] =
                (byte)(k[i] ^ plain[i + plainOffset]);
        }
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        System.arraycopy(k, 0, register, nShift, numBytes);
    }
    return plainLen;
}
 

private Session openSession() throws PKCS11Exception {
    if ((maxSessions != Integer.MAX_VALUE) &&
            (activeSessions.get() >= maxSessions)) {
        throw new ProviderException("No more sessions available");
    }

    long id = token.p11.C_OpenSession
                (token.provider.slotID, openSessionFlags, null, null);
    Session session = new Session(token, id);
    activeSessions.incrementAndGet();
    if (debug != null) {
        synchronized(maxActiveSessionsLock) {
            if (activeSessions.get() > maxActiveSessions) {
                maxActiveSessions = activeSessions.get();
                if (maxActiveSessions % 10 == 0) {
                    System.out.println("Open sessions: " + maxActiveSessions);
                }
            }
        }
    }
    return session;
}
 

Session getOpSession() throws PKCS11Exception {
    Session session = opSessions.poll();
    if (session != null) {
        return ensureValid(session);
    }
    // create a new session rather than re-using an obj session
    // that avoids potential expensive cancels() for Signatures & RSACipher
    if (maxSessions == Integer.MAX_VALUE ||
            activeSessions.get() < maxSessions) {
        session = openSession();
        return ensureValid(session);
    }
    session = objSessions.poll();
    if (session != null) {
        return ensureValid(session);
    }
    throw new ProviderException("Could not obtain session");
}
 

static void test(String algo, Provider provider, boolean priv,
        Consumer<Key> method) throws Exception {
    KeyPairGenerator generator;
    try {
        generator = KeyPairGenerator.getInstance(algo, provider);
    } catch (NoSuchAlgorithmException nsae) {
        return;
    }

    System.out.println("Checking " + provider.getName() + ", " + algo);

    KeyPair pair = generator.generateKeyPair();
    Key key = priv ? pair.getPrivate() : pair.getPublic();

    pair = null;
    for (int i = 0; i < 32; ++i) {
        System.gc();
    }

    try {
        method.accept(key);
    } catch (ProviderException pe) {
        failures++;
    }
}
 

Session getOpSession() throws PKCS11Exception {
    Session session = opSessions.poll();
    if (session != null) {
        return ensureValid(session);
    }
    // create a new session rather than re-using an obj session
    // that avoids potential expensive cancels() for Signatures & RSACipher
    if (maxSessions == Integer.MAX_VALUE ||
            activeSessions.get() < maxSessions) {
        session = openSession();
        return ensureValid(session);
    }
    session = objSessions.poll();
    if (session != null) {
        return ensureValid(session);
    }
    throw new ProviderException("Could not obtain session");
}
 

private Session openSession() throws PKCS11Exception {
    if ((maxSessions != Integer.MAX_VALUE) &&
            (activeSessions.get() >= maxSessions)) {
        throw new ProviderException("No more sessions available");
    }

    long id = token.p11.C_OpenSession
                (token.provider.slotID, openSessionFlags, null, null);
    Session session = new Session(token, id);
    activeSessions.incrementAndGet();
    if (debug != null) {
        synchronized(maxActiveSessionsLock) {
            if (activeSessions.get() > maxActiveSessions) {
                maxActiveSessions = activeSessions.get();
                if (maxActiveSessions % 10 == 0) {
                    System.out.println("Open sessions: " + maxActiveSessions);
                }
            }
        }
    }
    return session;
}
 

static void test(String algo, Provider provider, boolean priv,
        Consumer<Key> method) throws Exception {
    KeyPairGenerator generator;
    try {
        generator = KeyPairGenerator.getInstance(algo, provider);
    } catch (NoSuchAlgorithmException nsae) {
        return;
    }

    System.out.println("Checking " + provider.getName() + ", " + algo);

    KeyPair pair = generator.generateKeyPair();
    Key key = priv ? pair.getPrivate() : pair.getPublic();

    pair = null;
    for (int i = 0; i < 32; ++i) {
        System.gc();
    }

    try {
        method.accept(key);
    } catch (ProviderException pe) {
        failures++;
    }
}
 

static void test(String algo, Provider provider, boolean priv,
        Consumer<Key> method) throws Exception {
    KeyPairGenerator generator;
    try {
        generator = KeyPairGenerator.getInstance(algo, provider);
    } catch (NoSuchAlgorithmException nsae) {
        return;
    }

    System.out.println("Checking " + provider.getName() + ", " + algo);

    KeyPair pair = generator.generateKeyPair();
    Key key = priv ? pair.getPrivate() : pair.getPublic();

    pair = null;
    for (int i = 0; i < 32; ++i) {
        System.gc();
    }

    try {
        method.accept(key);
    } catch (ProviderException pe) {
        failures++;
    }
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset) {
    if ((plainLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }

    int nShift = blockSize - numBytes;
    int loopCount = plainLen / numBytes;

    for (; loopCount > 0 ;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        for (int i = 0; i < numBytes; i++) {
            register[nShift + i] = cipher[i + cipherOffset] =
                    (byte)(k[i] ^ plain[i + plainOffset]);
        }
    }
    return plainLen;
}
 

@Override
public Object newInstance(Object ctrParamObj)
    throws NoSuchAlgorithmException {
    String type = getType();
    if (ctrParamObj != null) {
        throw new InvalidParameterException
            ("constructorParameter not used with " + type + " engines");
    }
    String algo = getAlgorithm();
    // GSSAPI uses same impl class for client and server
    try {
        if (algo.equals("GSSAPI")) {
            return new com.sun.security.sasl.gsskerb.FactoryImpl();
        }
    } catch (Exception ex) {
        throw new NoSuchAlgorithmException("Error constructing " +
             type + " for " + algo + " using JdkSASL", ex);
    }
    throw new ProviderException("No impl for " + algo +
        " " + type);
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset) {

    if ((plainLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }
    int nShift = blockSize - numBytes;
    int loopCount = plainLen / numBytes;

    for (; loopCount > 0;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        for (int i = 0; i < numBytes; i++) {
            cipher[i + cipherOffset] =
                (byte)(k[i] ^ plain[i + plainOffset]);
        }
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        System.arraycopy(k, 0, register, nShift, numBytes);
    }
    return plainLen;
}
 

/**
 * Performs decryption operation.
 *
 * <p>The input cipher text <code>cipher</code>, starting at
 * <code>cipherOffset</code> and ending at
 * <code>(cipherOffset + cipherLen - 1)</code>, is decrypted.
 * The result is stored in <code>plain</code>, starting at
 * <code>plainOffset</code>.
 *
 * @param cipher the buffer with the input data to be decrypted
 * @param cipherOffset the offset in <code>cipherOffset</code>
 * @param cipherLen the length of the input data
 * @param plain the buffer for the result
 * @param plainOffset the offset in <code>plain</code>
 * @exception ProviderException if <code>cipherLen</code> is not
 * a multiple of the <code>numBytes</code>
 * @return the length of the decrypted data
 */
int decrypt(byte[] cipher, int cipherOffset, int cipherLen,
            byte[] plain, int plainOffset) {
    if ((cipherLen % numBytes) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }

    int nShift = blockSize - numBytes;
    int loopCount = cipherLen / numBytes;

    for (; loopCount > 0;
         plainOffset += numBytes, cipherOffset += numBytes,
         loopCount--) {
        embeddedCipher.encryptBlock(register, 0, k, 0);
        if (nShift != 0) {
            System.arraycopy(register, numBytes, register, 0, nShift);
        }
        for (int i = 0; i < numBytes; i++) {
            register[i + nShift] = cipher[i + cipherOffset];
            plain[i + plainOffset]
                = (byte)(cipher[i + cipherOffset] ^ k[i]);
        }
    }
    return cipherLen;
}
 

private Session openSession() throws PKCS11Exception {
    if ((maxSessions != Integer.MAX_VALUE) &&
            (activeSessions.get() >= maxSessions)) {
        throw new ProviderException("No more sessions available");
    }

    long id = token.p11.C_OpenSession
                (token.provider.slotID, openSessionFlags, null, null);
    Session session = new Session(token, id);
    activeSessions.incrementAndGet();
    if (debug != null) {
        synchronized(maxActiveSessionsLock) {
            if (activeSessions.get() > maxActiveSessions) {
                maxActiveSessions = activeSessions.get();
                if (maxActiveSessions % 10 == 0) {
                    System.out.println("Open sessions: " + maxActiveSessions);
                }
            }
        }
    }
    return session;
}
 

/**
 * Performs encryption operation.
 *
 * <p>The input plain text <code>plain</code>, starting at
 * <code>plainOffset</code> and ending at
 * <code>(plainOffset + plainLen - 1)</code>, is encrypted.
 * The result is stored in <code>cipher</code>, starting at
 * <code>cipherOffset</code>.
 *
 * @param plain the buffer with the input data to be encrypted
 * @param plainOffset the offset in <code>plain</code>
 * @param plainLen the length of the input data
 * @param cipher the buffer for the result
 * @param cipherOffset the offset in <code>cipher</code>
 * @exception ProviderException if <code>plainLen</code> is not
 * a multiple of the block size
 * @return the length of the encrypted data
 */
int encrypt(byte[] plain, int plainOffset, int plainLen,
            byte[] cipher, int cipherOffset)
{
    if ((plainLen % blockSize) != 0) {
        throw new ProviderException("Internal error in input buffering");
    }
    int i;
    int endIndex = plainOffset + plainLen;

    for (; plainOffset < endIndex;
         plainOffset += blockSize, cipherOffset += blockSize) {
        for (i = 0; i < blockSize; i++) {
            k[i] ^= plain[i + plainOffset];
        }
        embeddedCipher.encryptBlock(k, 0, cipher, cipherOffset);
        for (i = 0; i < blockSize; i++) {
            k[i] = (byte)(plain[i + plainOffset] ^ cipher[i + cipherOffset]);
        }
    }
    return plainLen;
}
 

/**
 * Generates a user-specified number of random bytes.
 *
 * @param bytes the array to be filled in with random bytes.
 */
@Override
protected void engineNextBytes(byte[] bytes) {
    if (bytes != null) {
        if (generateSeed(0, bytes) == null) {
            throw new ProviderException("Error generating random bytes");
        }
    }
}
 

/**
 * Constructs a new RSASignature. Used by subclasses.
 */
RSASignature(String digestName) {

    try {
        messageDigest = MessageDigest.getInstance(digestName);
        // Get the digest's canonical name
        messageDigestAlgorithm = messageDigest.getAlgorithm();

    } catch (NoSuchAlgorithmException e) {
       throw new ProviderException(e);
    }

    needsReset = false;
}
 

protected final byte[] engineDigest() {
    byte[] b = new byte[digestLength];
    try {
        engineDigest(b, 0, b.length);
    } catch (DigestException e) {
        throw (ProviderException)
            new ProviderException("Internal error").initCause(e);
    }
    return b;
}
 

/**
 * Returns the given number of seed bytes.  This call may be used to
 * seed other random number generators.
 *
 * @param numBytes the number of seed bytes to generate.
 *
 * @return the seed bytes.
 */
@Override
protected byte[] engineGenerateSeed(int numBytes) {
    byte[] seed = generateSeed(numBytes, null);

    if (seed == null) {
        throw new ProviderException("Error generating seed bytes");
    }
    return seed;
}
 

/**
 * Generates a user-specified number of random bytes.
 *
 * @param bytes the array to be filled in with random bytes.
 */
@Override
protected void engineNextBytes(byte[] bytes) {
    if (bytes != null) {
        if (generateSeed(0, bytes) == null) {
            throw new ProviderException("Error generating random bytes");
        }
    }
}