Java DestroyFailedException类代码示例

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
/**
 * 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;
    }
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
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");
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
protected void resetMechanism() throws SaslException
{
  try
    {
      password.destroy();
    }
  catch (DestroyFailedException dfe)
    {
      SaslException se = new SaslException("resetMechanism()");
      se.initCause(dfe);
      throw se;
    }
  password = null;
  M1 = null;
  K = null;
  cIV = null;
  sIV = null;
  inMac = outMac = null;
  inCipher = outCipher = null;
  sid = null;
  ttl = 0;
  cn = null;
  sn = null;
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
private void populateSubjectWithTGT(Subject subject, Map<String, String> credentials) {
    KerberosTicket tgt = getTGT(credentials);
    if (tgt != null) {
        Set<Object> creds = subject.getPrivateCredentials();
        synchronized (creds) {
            Iterator<Object> iterator = creds.iterator();
            while (iterator.hasNext()) {
                Object o = iterator.next();
                if (o instanceof KerberosTicket) {
                    KerberosTicket t = (KerberosTicket) o;
                    iterator.remove();
                    try {
                        t.destroy();
                    } catch (DestroyFailedException e) {
                        LOG.warn("Failed to destory ticket ", e);
                    }
                }
            }
            creds.add(tgt);
        }
        subject.getPrincipals().add(tgt.getClient());
        kerbTicket.set(tgt);
    } else {
        LOG.info("No TGT found in credentials");
    }
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
public void destroy() throws DestroyFailedException
{
	if (this.children != null)
	{
		for (Destroyable destroyable : this.children)
		{
			if (destroyable.isDestroyed()) continue;
			
			if (destroyable instanceof DestroyableChild)
				((DestroyableChild)destroyable).unlink();
			
			destroyable.destroy();
		}
		
		this.children = null;
	}
	super.destroy();
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
/**
 * Closes the session of a successful call to {@link #open(LoadStoreParameter)}
 * and log any error, that might occur.
 */
public void close()
{
    if (this.slot != null)
    {
        try
        {
            this.slot.destroy();
        } catch (DestroyFailedException e)
        {
            log.warn("Cannot destroy slot:",e);
        }
    }        
    
    this.slot = null;
    this.session = null;
    this.protectionParameter = null;
    this.cb = null;
    this.eventHandler = null;
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
private void fixKerberosTicketOrder() {
  Set<Object> creds = getSubject().getPrivateCredentials();
  synchronized (creds) {
    for (Iterator<Object> iter = creds.iterator(); iter.hasNext();) {
      Object cred = iter.next();
      if (cred instanceof KerberosTicket) {
        KerberosTicket ticket = (KerberosTicket) cred;
        if (!ticket.getServer().getName().startsWith("krbtgt")) {
          LOG.warn("The first kerberos ticket is not TGT"
              + "(the server principal is {}), remove and destroy it.",
              ticket.getServer());
          iter.remove();
          try {
            ticket.destroy();
          } catch (DestroyFailedException e) {
            LOG.warn("destroy ticket failed", e);
          }
        } else {
          return;
        }
      }
    }
  }
  LOG.warn("Warning, no kerberos ticket found while attempting to renew" +
      " ticket");
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
/**
 * Test for <code>KeyStore.PasswordProtection(char[] password)</code> constructor
 * and the following methods 
 * <code>getPassword()<code>
 * <code>destroy()<code>
 * <code>isDestroyed()<code>
 * Assertions: constructor created new PasswordProtection object
 * getPassword() returns password or throws IllegalArgumentException
 * if PasswordProtection is destroyed
 */
public void testGetPassword() throws DestroyFailedException {
    char [] pass = {'a', 'b', 'c'};
    KeyStore.PasswordProtection ksPWP = new KeyStore.PasswordProtection(pass);
    char [] rPass = ksPWP.getPassword();
    assertFalse("PasswordProtection Should not be destroyed", ksPWP.isDestroyed());        
    assertEquals("Incorrect password length", pass.length, rPass.length);
    for (int i = 0; i < pass.length; i++) {
        assertEquals("Incorrect password (item: ".concat(Integer.toString(i))
                .concat(")"), pass[i], rPass[i]);
    }
    ksPWP.destroy();
    assertTrue("PasswordProtection must be destroyed", ksPWP.isDestroyed());
    try {
        ksPWP.getPassword();
        fail("IllegalStateException must be thrown because PasswordProtection is destroyed");
    } catch (IllegalStateException e) {
    }
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
public boolean logout() throws LoginException {

        subject.getPrincipals().remove(client);
        subject.getPrivateCredentials().remove(krbTicket);
        
        try {
            krbTicket.destroy();
        } catch (DestroyFailedException e) {
            throw new LoginException();
        }

        client = null;
        krbTicket = null;

        return true;
    }
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
public void destroy() throws DestroyFailedException {
    if (destroyed) {
        return;
    }
    Arrays.fill(this.asn1Encoding, (byte) 0);
    this.client = null;
    this.server = null;
    this.sessionKey.destroy();
    this.flags = null;
    this.authTime = null;
    this.startTime = null;
    this.endTime = null;
    this.renewTill = null;
    this.clientAddresses = null;
    destroyed = true;
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
/**
 * @tests javax.security.auth.kerberos.KerberosKey#equals(java.lang.Object)
 */
public void test_equals() {
    KerberosKey kerberosKey1 = new KerberosKey(principal, keyBytes, 1, 123);
    KerberosKey kerberosKey2 = new KerberosKey(principal, keyBytes, 1, 123);
    KerberosKey kerberosKey3 = new KerberosKey(principal, new byte[] { 1,
            3, 4, 5 }, 1, 123);
    assertEquals("kerberosKey1 and kerberosKey2 should be equivalent ",
            kerberosKey1, kerberosKey2);
    assertFalse("kerberosKey1 and kerberosKey3 sholudn't be equivalent ",
            kerberosKey1.equals(kerberosKey3));
    try {
        kerberosKey2.destroy();
    } catch (DestroyFailedException e) {
        fail("kerberosKey2 destroy failed");
    }
    assertFalse("Destroyed kerberosKey sholudn't be equivalent ",
            kerberosKey1.equals(kerberosKey2));
}
 

import javax.security.auth.DestroyFailedException; //导入依赖的package包/类
/**
 * Attempts to destroy an object's data
 *
 * @param object Object to destroy
 */
public static void destroy(Object object) {
    if (object instanceof byte[]) {
        zero((byte[]) object);
    } else if (object instanceof char[]) {
        zero((char[]) object);
    } else if (object instanceof Destroyable) {
        ((Destroyable) object).destroy();
    } else if (object instanceof javax.security.auth.Destroyable && !((javax.security.auth.Destroyable) object).isDestroyed()) {
        try {
            ((javax.security.auth.Destroyable) object).destroy();
        } catch (DestroyFailedException e) {
            // JCE keys generally fail even then they pretend to be destroyable so don't log other those will spam
        }
    }
}