Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import java.security.SecureClassLoader; /** * The FireWallClassLoader is a classloader that can block request from going up * in the classloader hierarchy. * <P> * Normally, when a classloader receives a request for a resource, it will * consult its parent class loader first for that resource. The parent class * loader is typically the System ClassLoader. If the parent class loader cannot * provide the requested resource, the child class loader will be consulted for * the request. <I>Note: the parent class loader must not be confused by the * superclass of a certain class loader (e.g. SecureClassLoader). The parent * classloader is identified at constuction time and passed in as an constructor * argument.</I> * <P> * Consulting the parent classloader first can be inconvenient for certain * applications that want guarantees about which classloader is used to load a * certain class. This could be because you want to be certain about where the * resource came from, or you want to protect yourself against (other versions) * of the same class that could be served by the System ClassLoader (e.g. * because someone put them on the classpath or in the extensions directory). * <P> * For these cases, the FireWallClassLoader can be used. * * <PRE> * * System ClassLoader | FireWallClassLoader | User's ClassLoader * * </PRE> * * The FireWallClassLoader is placed between the user's class loader and the * parent class loader. It has a set of filters that define what classes are * allowed to go through. These filters describe (a groups of) packages, or a * specific classes or resources that are allowed through to the parent * classloader. Take as example this filter set: * * <pre> * ["com.iona.", "javax.servlet.jsp."] * </pre> * * This will allow requests to any class/resource staring with com.iona. or * javax.servlet.jsp. through to the parent classloader and block all other * requests. * <P> * A very common set of filters would be a set that allows nothing through * except the classes used by the JDK. The {@link JDKFireWallClassLoaderFactory} * factory class can create such FireWallClassLoader. * <P> * The FireWallClassLoader does not load any classes. */ public class FireWallClassLoader extends SecureClassLoader { private final String[] filters; private final String[] fnFilters; private final String[] negativeFilters; private final String[] negativeFNFilters; /** * Constructor. * * @param parent The Parent ClassLoader to use. * @param fs A set of filters to let through. The filters and be either in * package form (<CODE>org.omg.</CODE> or <CODE>org.omg.*</CODE>) * or specify a single class (<CODE>junit.framework.TestCase</CODE>). * <P> * When the package form is used, all classed in all subpackages * of this package are let trough the firewall. When the class * form is used, the filter only lets that single class through. * Note that when that class depends on another class, this class * does not need to be mentioned as a filter, because if the * originating class is loaded by the parent classloader, the * FireWallClassLoader will not receive requests for the * dependant class. */ public FireWallClassLoader(ClassLoader parent, String[] fs) { this(parent, fs, new String[0]); } /** * Constructor. * * @param parent The Parent ClassLoader to use. * @param fs A set of filters to let through. The filters and be either in * package form (<CODE>org.omg.</CODE> or <CODE>org.omg.*</CODE>) * or specify a single class (<CODE>junit.framework.TestCase</CODE>). * <P> * When the package form is used, all classed in all subpackages * of this package are let trough the firewall. When the class * form is used, the filter only lets that single class through. * Note that when that class depends on another class, this class * does not need to be mentioned as a filter, because if the * originating class is loaded by the parent classloader, the * FireWallClassLoader will not receive requests for the * dependant class. * @param negativeFs List of negative filters to use. Negative filters take * precedence over positive filters. When a class or resource is * requested that matches a negative filter it is not let through * the firewall even if an allowing filter would exist in the * positive filter list. */ public FireWallClassLoader(ClassLoader parent, String[] fs, String[] negativeFs) { super(parent); this.filters = processFilters(fs); this.negativeFilters = processFilters(negativeFs); this.fnFilters = filters2FNFilters(this.filters); this.negativeFNFilters = filters2FNFilters(this.negativeFilters); boolean javaCovered = false; if (this.filters == null) { javaCovered = true; } else { for (int i = 0; i < this.filters.length; i++) { if (this.filters[i].equals("java.")) { javaCovered = true; } } } if (this.negativeFilters != null) { String java = "java."; // try all that would match java: j, ja, jav, java and java. for (int i = java.length(); i >= 0; i--) { for (int j = 0; j < this.negativeFilters.length; j++) { if (negativeFilters[j].equals(java.substring(0, i))) { javaCovered = false; } } } } if (!javaCovered) { throw new SecurityException("It's unsafe to construct a " + "FireWallClassLoader that does not let the java. " + "package through."); } } private static String[] processFilters(String[] fs) { if (fs == null || fs.length == 0) { return null; } String[] f = new String[fs.length]; for (int i = 0; i < fs.length; i++) { String filter = fs[i]; if (filter.endsWith("*")) { filter = filter.substring(0, filter.length() - 1); } f[i] = filter; } return f; } private static String[] filters2FNFilters(String[] fs) { if (fs == null || fs.length == 0) { return null; } String[] f = new String[fs.length]; for (int i = 0; i < fs.length; i++) { f[i] = fs[i].replace('.', '/'); } return f; } protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { if (negativeFilters != null) { for (int i = 0; i < negativeFilters.length; i++) { if (name.startsWith(negativeFilters[i])) { throw new ClassNotFoundException(name); } } } if (filters != null) { for (int i = 0; i < filters.length; i++) { if (name.startsWith(filters[i])) { return super.loadClass(name, resolve); } } } else { return super.loadClass(name, resolve); } throw new ClassNotFoundException(name); } /*protected Class<?> findClass(String name) throws ClassNotFoundException { if (negativeFilters != null) { for (int i = 0; i < negativeFilters.length; i++) { if (name.startsWith(negativeFilters[i])) { throw new ClassNotFoundException(name); } } } if (filters != null) { for (int i = 0; i < filters.length; i++) { if (name.startsWith(filters[i])) { return super.findClass(name); } } } else { return super.loadClass(name); } throw new ClassNotFoundException(name); }*/ public java.net.URL getResource(String name) { if (negativeFNFilters != null) { for (int i = 0; i < negativeFNFilters.length; i++) { if (name.startsWith(negativeFNFilters[i])) { return null; } } } if (fnFilters != null) { for (int i = 0; i < fnFilters.length; i++) { if (name.startsWith(fnFilters[i])) { return super.getResource(name); } } } else { return super.getResource(name); } return null; } /** * Returns the list of filters used by this FireWallClassLoader. The list is * a copy of the array internally used. * * @return The filters used. */ public String[] getFilters() { if (filters == null) { return null; } return (String[]) filters.clone(); } /** * Returns the list of negative filters used by this FireWallClassLoader. * The list is a copy of the array internally used. * * @return The filters used. */ public String[] getNegativeFilters() { if (negativeFilters == null) { return null; } return (String[]) negativeFilters.clone(); } }