Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2007, 2010 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
 
 package org.eclipse.osgi.internal.service.security;
 
 import java.io.*;
 
 //*potential enhancements*
 // 1. reloading from the backing file when it changes
 // 3. methods to support lock/unlock
 //  3a. Using a callback handler to collect the password
 //  3b. managing lock/unlock between multiple threads. dealing with SWT UI thread
 // 4. methods to support changing password, etc
 // 5. methods to support export, etc
 // 6. 'friendly-name' generator
 // 7. Listeners for change events
 public class KeyStoreTrustEngine extends TrustEngine {
 
 	private KeyStore keyStore;
 
 	private final String type;
 	private final String path;
 	private final char[] password;
 	private final String name;

Create a new KeyStoreTrustEngine that is backed by a KeyStore

Parameters:
path - path to the keystore
type - the type of keystore at the path location
password - the password required to unlock the keystore
 
 	public KeyStoreTrustEngine(String pathString typechar[] passwordString name) { //TODO: This should be a *CallbackHandler*
 		this. = path;
 		this. = type;
 		this. = password;
 		this. = name;
 	}

Return the type

Returns:
type - the type for the KeyStore being managed
 
 	private String getType() {
 		return ;
 	}

Return the path

Returns:
- the path for the KeyStore being managed
 
 	private String getPath() {
 		return ;
 	}

Return the password

Returns:
password - the password as a char[]
 
 	private char[] getPassword() {
 		return ;
 	}

Return the KeyStore managed

Returns:
The KeyStore instance, initialized and loaded
Throws:
java.security.KeyStoreException
 
 	private synchronized KeyStore getKeyStore() throws IOExceptionGeneralSecurityException {
 		if (null == ) {
 			 = KeyStore.getInstance(getType());
 			final InputStream in = getInputStream();
 			try {
 			} finally {
 				try {
 					in.close();
 				} catch (IOException e) {
 					//ignore secondary failure
 				}
 			}
 		}
 
		if ( == null)
		return ;
	}
	public Certificate findTrustAnchor(Certificate[] certChainthrows IOException {
		if (certChain == null || certChain.length == 0)
			throw new IllegalArgumentException("Certificate chain is required"); //$NON-NLS-1$
		try {
			Certificate rootCert = null;
			KeyStore store = getKeyStore();
			for (int i = 0; i < certChain.lengthi++) {
				if (certChain[iinstanceof X509Certificate) {
					if (i == certChain.length - 1) {
						// this is the last certificate in the chain
						// determine if we have a valid root
						X509Certificate cert = (X509CertificatecertChain[i];
						if (cert.getSubjectDN().equals(cert.getIssuerDN())) {
							cert.verify(cert.getPublicKey());
							rootCert = cert// this is a self-signed certificate
else {
							// try to find a parent, we have an incomplete chain
							return findAlternativeRoot(certstore);
						}
else {
						X509Certificate nextX509Cert = (X509CertificatecertChain[i + 1];
						certChain[i].verify(nextX509Cert.getPublicKey());
					}
				}
				synchronized (store) {
					String alias = rootCert == null ? null : store.getCertificateAlias(rootCert);
					if (alias != null)
						return store.getCertificate(alias);
					else if (rootCert != certChain[i]) {
						alias = store.getCertificateAlias(certChain[i]);
						if (alias != null)
							return store.getCertificate(alias);
					}
					// if we have reached the end and the last cert is not found to be a valid root CA
					// then we need to back off the root CA and try to find an alternative
					if (certChain.length > 1 && i == certChain.length - 1 && certChain[i - 1] instanceof X509Certificate)
						return findAlternativeRoot((X509CertificatecertChain[i - 1], store);
				}
			}
catch (KeyStoreException e) {
catch (GeneralSecurityException e) {
			SignedBundleHook.log(e.getMessage(), .e);
			return null;
		}
		return null;
	}
		synchronized (store) {
			for (Enumeration e = store.aliases(); e.hasMoreElements();) {
				Certificate nextCert = store.getCertificate((Stringe.nextElement());
				if (nextCert instanceof X509Certificate && ((X509CertificatenextCert).getSubjectDN().equals(cert.getIssuerDN())) {
					cert.verify(nextCert.getPublicKey());
					return nextCert;
				}
			}
			return null;
		}
	}
		if (isReadOnly())
		if (cert == null) {
			throw new IllegalArgumentException("Certificate must be specified"); //$NON-NLS-1$
		}
		try {
			KeyStore store = getKeyStore();
			synchronized (store) {
				String oldAlias = store.getCertificateAlias(cert);
				if (null != oldAlias)
				Certificate oldCert = store.getCertificate(alias);
				if (null != oldCert)
				store.setCertificateEntry(aliascert);
				final OutputStream out = getOutputStream();
				try {
					saveStore(storeout);
finally {
				}
			}
catch (KeyStoreException ke) {
		}
		return alias;
	}
		if (isReadOnly())
		if (cert == null) {
			throw new IllegalArgumentException("Certificate must be specified"); //$NON-NLS-1$
		}
		try {
			KeyStore store = getKeyStore();
			synchronized (store) {
				String alias = store.getCertificateAlias(cert);
				if (alias == null) {
				}
			}
catch (KeyStoreException ke) {
		}
	}
	protected void doRemoveTrustAnchor(String aliasthrows IOExceptionGeneralSecurityException {
		if (alias == null) {
			throw new IllegalArgumentException("Alias must be specified"); //$NON-NLS-1$
		}
		try {
			KeyStore store = getKeyStore();
			synchronized (store) {
				Certificate oldCert = store.getCertificate(alias);
				if (oldCert == null)
				store.deleteEntry(alias);
				final OutputStream out = getOutputStream();
				try {
					saveStore(storeout);
finally {
				}
			}
catch (KeyStoreException ke) {
		}
	}
		if (alias == null) {
			throw new IllegalArgumentException("Alias must be specified"); //$NON-NLS-1$
		}
		try {
			KeyStore store = getKeyStore();
			synchronized (store) {
				return store.getCertificate(alias);
			}
catch (KeyStoreException ke) {
		}
	}
		ArrayList returnList = new ArrayList();
		try {
			KeyStore store = getKeyStore();
			synchronized (store) {
				for (Enumeration aliases = store.aliases(); aliases.hasMoreElements();) {
					String currentAlias = (Stringaliases.nextElement();
					if (store.isCertificateEntry(currentAlias)) {
						returnList.add(currentAlias);
					}
				}
			}
catch (KeyStoreException ke) {
		}
		return (String[]) returnList.toArray(new String[] {});
	}

Load using the current password
	private void loadStore(KeyStore storeInputStream isthrows IOExceptionGeneralSecurityException {
		store.load(isgetPassword());
	}

Save using the current password
	private void saveStore(KeyStore storeOutputStream osthrows IOExceptionGeneralSecurityException {
		store.store(osgetPassword());
	}

Closes a stream and ignores any resulting exception. This is useful when doing stream cleanup in a finally block where secondary exceptions are not worth logging.
	private void safeClose(OutputStream out) {
		try {
			if (out != null)
				out.close();
catch (IOException e) {
			//ignore
		}
	}

Get an input stream for the KeyStore managed

Returns:
inputstream - the stream
Throws:
java.security.KeyStoreException
	private InputStream getInputStream() throws IOException {
		return new FileInputStream(new File(getPath()));
	}

Get an output stream for the KeyStore managed

Returns:
outputstream - the stream
Throws:
java.security.KeyStoreException
		File file = new File(getPath());
		if (!file.exists())
		return new FileOutputStream(file);
	}
	public boolean isReadOnly() {
		return getPassword() == null || !(new File().canWrite());
	}
	public String getName() {
		return ;
	}
New to GrepCode? Check out our FAQ X