Back to index...

	/*
	* Copyright (c) 2007, 2014, 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 javax.crypto;

	import java.io.*;
	import java.net.*;
	import java.security.*;
	import java.util.jar.*;

	/**
	* This class verifies Provider/Policy resources found at a URL
	* (currently only JAR files and any supporting JAR files), and
	* determines whether they may be used in this implementation.
	*
	* The JCE in OpenJDK has an open cryptographic interface, meaning it
	* does not restrict which providers can be used. Compliance with
	* United States export controls and with local law governing the
	* import/export of products incorporating the JCE in the OpenJDK is
	* the responsibility of the licensee.
	*
	* @since 1.7
	*/
	final class ProviderVerifier {

	// The URL for the JAR file we want to verify.
	private URL jarURL;
	private Provider provider;
	private boolean savePerms;
	private CryptoPermissions appPerms = null;

	/**
	* Creates a ProviderVerifier object to verify the given URL.
	*
	* @param jarURL the JAR file to be verified.
	* @param savePerms if true, save the permissions allowed by the
	* exemption mechanism
	*/
	ProviderVerifier(URL jarURL, boolean savePerms) {
	this(jarURL, null, savePerms);
	}

	/**
	* Creates a ProviderVerifier object to verify the given URL.
	*
	* @param jarURL the JAR file to be verified
	* @param provider the corresponding provider.
	* @param savePerms if true, save the permissions allowed by the
	* exemption mechanism
	*/
	ProviderVerifier(URL jarURL, Provider provider, boolean savePerms) {
	this.jarURL = jarURL;
	this.provider = provider;
	this.savePerms = savePerms;
	}

	/**
	* Verify the JAR file is signed by an entity which has a certificate
	* issued by a trusted CA.
	*
	* In OpenJDK, we just need to examine the "cryptoperms" file to see
	* if any permissions were bundled together with this jar file.
	*/
	void verify() throws IOException {

	// Short-circuit. If we weren't asked to save any, we're done.
	if (!savePerms) {
	return;
	}

	// If the protocol of jarURL isn't "jar", we should
	// construct a JAR URL so we can open a JarURLConnection
	// for verifying this provider.
	final URL url = jarURL.getProtocol().equalsIgnoreCase("jar")?
	jarURL : new URL("jar:" + jarURL.toString() + "!/");

	JarFile jf = null;
	try {

	// Get a link to the Jarfile to search.
	try {
	jf = AccessController.doPrivileged(
	new PrivilegedExceptionAction<JarFile>() {
	public JarFile run() throws Exception {
	JarURLConnection conn =
	(JarURLConnection) url.openConnection();
	// You could do some caching here as
	// an optimization.
	conn.setUseCaches(false);
	return conn.getJarFile();
	}
	});
	} catch (java.security.PrivilegedActionException pae) {
	throw new SecurityException("Cannot load " + url.toString(),
	pae.getCause());
	}

	if (jf != null) {
	JarEntry je = jf.getJarEntry("cryptoPerms");
	if (je == null) {
	throw new JarException(
	"Can not find cryptoPerms");
	}
	try {
	appPerms = new CryptoPermissions();
	appPerms.load(jf.getInputStream(je));
	} catch (Exception ex) {
	JarException jex =
	new JarException("Cannot load/parse" +
	jarURL.toString());
	jex.initCause(ex);
	throw jex;
	}
	}
	} finally {
	// Only call close() when caching is not enabled.
	// Otherwise, exceptions will be thrown for all
	// subsequent accesses of this cached jar.
	if (jf != null) {
	jf.close();
	}
	}
	}

	/**
	* Verify that the provided certs include the
	* framework signing certificate.
	*
	* @param certs the list of certs to be checked.
	* @throws Exception if the list of certs did not contain
	* the framework signing certificate
	*/
	static void verifyPolicySigned(java.security.cert.Certificate[] certs)
	throws Exception {
	}

	/**
	* Returns true if the given provider is JDK trusted crypto provider
	* if the implementation supports fast-path verification.
	*/
	static boolean isTrustedCryptoProvider(Provider provider) {
	return false;
	}

	/**
	* Returns the permissions which are bundled with the JAR file,
	* aka the "cryptoperms" file.
	*
	* NOTE: if this ProviderVerifier instance is constructed with "savePerms"
	* equal to false, then this method would always return null.
	*/
	CryptoPermissions getPermissions() {
	return appPerms;
	}
	}

Back to index...