javax.security.auth.DestroyFailedException Java Examples

/**
 * Destroys the ticket and destroys any sensitive information stored in
 * it.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        Arrays.fill(asn1Encoding, (byte) 0);
        client = null;
        server = null;
        sessionKey.destroy();
        flags = null;
        authTime = null;
        startTime = null;
        endTime = null;
        renewTill = null;
        clientAddresses = null;
        destroyed = true;
    }
}
 

/**
 * Test for <code>KeyStore.PasswordProtection(char[] password, String protectionAlgorithm,
 * AlgorithmParameterSpec protectionParameters)</code> constructor
 * and the method <code>getProtectionAlgorithm()</code>

 * Assertions: constructor throws NullPointerException if protectionAlgorithm is null.
 * getProtectionAlgorithm() returns the protection algorithm passed in the constructor.
 */
public void testGetProtectionAlgorithm() throws DestroyFailedException {
    char [] pass = {'a', 'b', 'c'};
    String protectionAlgorithm = "ThisBeautifulAlgorithm";
    AlgorithmParameterSpec protectionParameters = new IvParameterSpec(new byte[]{});
    KeyStore.PasswordProtection ksPWP;
    try {
        ksPWP = new KeyStore.PasswordProtection(
                pass, null /* protectionAlgorithm */, protectionParameters);
        fail("Expected null pointer exception");
    } catch (NullPointerException expected) {
    }
    ksPWP = new KeyStore.PasswordProtection(
            pass, protectionAlgorithm, null /* protectionParameters */);
    assertSame(protectionAlgorithm, ksPWP.getProtectionAlgorithm());
}
 

private static void testNoKeyDestruction(Destroyable key)
    throws Exception {
    String klass = key.getClass().getName();

    if (key.isDestroyed()) {
        throw new Exception("error: a " + klass +
            " key has been unexpectedly destroyed");
    }
    try {
        key.destroy();
    } catch (DestroyFailedException dfe) {
        // not an error

        if (key.isDestroyed()) {
            throw new Exception("error: a " + klass +
                " key has been unexpectedly destroyed");
        }
        System.out.println(klass + " keys are not destroyable");
        return;
    }
    throw new Exception("error: key may been unexpectedly destroyed");
}
 

private static void testNoKeyDestruction(Destroyable key)
    throws Exception {
    String klass = key.getClass().getName();

    if (key.isDestroyed()) {
        throw new Exception("error: a " + klass +
            " key has been unexpectedly destroyed");
    }
    try {
        key.destroy();
    } catch (DestroyFailedException dfe) {
        // not an error

        if (key.isDestroyed()) {
            throw new Exception("error: a " + klass +
                " key has been unexpectedly destroyed");
        }
        System.out.println(klass + " keys are not destroyable");
        return;
    }
    throw new Exception("error: key may been unexpectedly destroyed");
}
 

private static void testNoKeyDestruction(Destroyable key)
    throws Exception {
    String klass = key.getClass().getName();

    if (key.isDestroyed()) {
        throw new Exception("error: a " + klass +
            " key has been unexpectedly destroyed");
    }
    try {
        key.destroy();
    } catch (DestroyFailedException dfe) {
        // not an error

        if (key.isDestroyed()) {
            throw new Exception("error: a " + klass +
                " key has been unexpectedly destroyed");
        }
        System.out.println(klass + " keys are not destroyable");
        return;
    }
    throw new Exception("error: key may been unexpectedly destroyed");
}
 

public static RefreshToken decryptRefreshToken(OAuthDataProvider provider,
                                              String encodedToken,
                                              String encodedSecretKey,
                                              KeyProperties props) throws SecurityException {
    SecretKey key = CryptoUtils.decodeSecretKey(encodedSecretKey, props.getKeyAlgo());
    RefreshToken refreshToken = decryptRefreshToken(provider, encodedToken, key, props);

    // Clean the secret key from memory when we're done
    try {
        key.destroy();
    } catch (DestroyFailedException ex) {
        // ignore
    }

    return refreshToken;
}
 

protected byte[] encryptInternal(JweEncryptionInternal state, byte[] content) {
    try {
        SecretKey createCekSecretKey = createCekSecretKey(state);
        byte[] encryptedBytes = CryptoUtils.encryptBytes(content, createCekSecretKey, state.keyProps);

        // Here we're finished with the SecretKey we created, so we can destroy it
        try {
            createCekSecretKey.destroy();
        } catch (DestroyFailedException e) {
            // ignore
        }
        return encryptedBytes;
    } catch (SecurityException ex) {
        LOG.fine(ex.getMessage());
        if (ex.getCause() instanceof NoSuchAlgorithmException) {
            LOG.warning("Unsupported algorithm: " + state.keyProps.getKeyAlgo());
            throw new JweException(JweException.Error.INVALID_CONTENT_ALGORITHM);
        }
        throw new JweException(JweException.Error.CONTENT_ENCRYPTION_FAILURE, ex);
    }
}
 

private static void testNoKeyDestruction(Destroyable key)
    throws Exception {
    String klass = key.getClass().getName();

    if (key.isDestroyed()) {
        throw new Exception("error: a " + klass +
            " key has been unexpectedly destroyed");
    }
    try {
        key.destroy();
    } catch (DestroyFailedException dfe) {
        // not an error

        if (key.isDestroyed()) {
            throw new Exception("error: a " + klass +
                " key has been unexpectedly destroyed");
        }
        System.out.println(klass + " keys are not destroyable");
        return;
    }
    throw new Exception("error: key may been unexpectedly destroyed");
}
 

public static byte[] wrapSecretKey(byte[] keyBytes,
                                   String keyAlgo,
                                   Key wrapperKey,
                                   KeyProperties wrapperKeyProps)  throws SecurityException {
    SecretKeySpec secretKey = new SecretKeySpec(keyBytes, convertJCECipherToSecretKeyName(keyAlgo));
    byte[] encryptedKey = wrapSecretKey(secretKey,
                         wrapperKey,
                         wrapperKeyProps);

    // Here we're finished with the SecretKey we created, so we can destroy it
    try {
        secretKey.destroy();
    } catch (DestroyFailedException e) {
        // ignore
    }
    return encryptedKey;
}
 

/**
 * Destroys the ticket and destroys any sensitive information stored in
 * it.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        Arrays.fill(asn1Encoding, (byte) 0);
        client = null;
        server = null;
        sessionKey.destroy();
        flags = null;
        authTime = null;
        startTime = null;
        endTime = null;
        renewTill = null;
        clientAddresses = null;
        destroyed = true;
    }
}
 

/**
 * Destroys the ticket and destroys any sensitive information stored in
 * it.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        Arrays.fill(asn1Encoding, (byte) 0);
        client = null;
        server = null;
        sessionKey.destroy();
        flags = null;
        authTime = null;
        startTime = null;
        endTime = null;
        renewTill = null;
        clientAddresses = null;
        destroyed = true;
    }
}
 

private static void testNoKeyDestruction(Destroyable key)
    throws Exception {
    String klass = key.getClass().getName();

    if (key.isDestroyed()) {
        throw new Exception("error: a " + klass +
            " key has been unexpectedly destroyed");
    }
    try {
        key.destroy();
    } catch (DestroyFailedException dfe) {
        // not an error

        if (key.isDestroyed()) {
            throw new Exception("error: a " + klass +
                " key has been unexpectedly destroyed");
        }
        System.out.println(klass + " keys are not destroyable");
        return;
    }
    throw new Exception("error: key may been unexpectedly destroyed");
}
 

/**
 * Destroys the ticket and destroys any sensitive information stored in
 * it.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        Arrays.fill(asn1Encoding, (byte) 0);
        client = null;
        server = null;
        sessionKey.destroy();
        flags = null;
        authTime = null;
        startTime = null;
        endTime = null;
        renewTill = null;
        clientAddresses = null;
        destroyed = true;
    }
}
 

@Override
public void destroy() throws DestroyFailedException {
    if (!this.isDestroyed) {
        Arrays.fill(encoded, (byte) 0);
        this.isDestroyed = true;
    }
}
 

/**
 * Destroys this key. A call to any of its other methods after this
 * will cause an  IllegalStateException to be thrown.
 *
 * @throws DestroyFailedException if some error occurs while destorying
 * this key.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        key.destroy();
        principal = null;
        destroyed = true;
    }
}
 

/**
 * Called to invalidate this credential element.
 */
public void dispose() throws GSSException {
    try {
        destroy();
    } catch (DestroyFailedException e) {
        GSSException gssException =
            new GSSException(GSSException.FAILURE, -1,
             "Could not destroy credentials - " + e.getMessage());
        gssException.initCause(e);
    }
}
 

/**
 * javax.security.auth.DestroyFailedException#DestroyFailedException(String msg)
 * Assertion: constructs with null parameter.
 */
public void testDestroyFailedException03() {
    String msg = null;
    DestroyFailedException dfE = new DestroyFailedException(msg);
    assertNull("getMessage() must return null.", dfE.getMessage());
    assertNull("getCause() must return null", dfE.getCause());
}
 

@Override
public void destroy() throws DestroyFailedException {
    if (!this.isDestroyed) {
        Arrays.fill(encoded, (byte) 0);
        this.isDestroyed = true;
    }
}
 

/**
 * Destroys this key. A call to any of its other methods after this
 * will cause an  IllegalStateException to be thrown.
 *
 * @throws DestroyFailedException if some error occurs while destorying
 * this key.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        key.destroy();
        principal = null;
        destroyed = true;
    }
}
 

/**
 * Clears the password.
 *
 * @exception DestroyFailedException if this method was unable
 *      to clear the password
 */
public synchronized void destroy() throws DestroyFailedException {
    destroyed = true;
    if (password != null) {
        Arrays.fill(password, ' ');
    }
}
 

/**
 * Clears the password.
 *
 * @exception DestroyFailedException if this method was unable
 *      to clear the password
 */
public synchronized void destroy() throws DestroyFailedException {
    destroyed = true;
    if (password != null) {
        Arrays.fill(password, ' ');
    }
}
 

/**
 * Called to invalidate this credential element.
 */
public void dispose() throws GSSException {
    try {
        destroy();
    } catch (DestroyFailedException e) {
        GSSException gssException =
            new GSSException(GSSException.FAILURE, -1,
             "Could not destroy credentials - " + e.getMessage());
        gssException.initCause(e);
    }
}
 

/**
 * Clears the password.
 *
 * @exception DestroyFailedException if this method was unable
 *      to clear the password
 */
public synchronized void destroy() throws DestroyFailedException {
    destroyed = true;
    if (password != null) {
        Arrays.fill(password, ' ');
    }
}
 

/**
 * Called to invalidate this credential element.
 */
public void dispose() throws GSSException {
    try {
        destroy();
    } catch (DestroyFailedException e) {
        GSSException gssException =
            new GSSException(GSSException.FAILURE, -1,
             "Could not destroy credentials - " + e.getMessage());
        gssException.initCause(e);
    }
}
 

/**
 * Destroys this key. A call to any of its other methods after this
 * will cause an  IllegalStateException to be thrown.
 *
 * @throws DestroyFailedException if some error occurs while destorying
 * this key.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        key.destroy();
        principal = null;
        destroyed = true;
    }
}
 

@Override
public void destroy() throws DestroyFailedException {
    if (!this.isDestroyed) {
        Arrays.fill(encoded, (byte) 0);
        this.isDestroyed = true;
    }
}
 

/**
 * Destroys this key. A call to any of its other methods after this
 * will cause an  IllegalStateException to be thrown.
 *
 * @throws DestroyFailedException if some error occurs while destorying
 * this key.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        key.destroy();
        principal = null;
        destroyed = true;
    }
}
 

/**
 * Destroys this key. A call to any of its other methods after this
 * will cause an  IllegalStateException to be thrown.
 *
 * @throws DestroyFailedException if some error occurs while destorying
 * this key.
 */
public void destroy() throws DestroyFailedException {
    if (!destroyed) {
        key.destroy();
        principal = null;
        destroyed = true;
    }
}
 

@Override
public void destroy() throws DestroyFailedException {
    if (!this.isDestroyed) {
        Arrays.fill(encoded, (byte) 0);
        this.isDestroyed = true;
    }
}
 

/**
 * Called to invalidate this credential element.
 */
public void dispose() throws GSSException {
    try {
        destroy();
    } catch (DestroyFailedException e) {
        GSSException gssException =
            new GSSException(GSSException.FAILURE, -1,
             "Could not destroy credentials - " + e.getMessage());
        gssException.initCause(e);
    }
}