org.apache.catalina.security.SecurityUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of payara-micro Show documentation
Show all versions of payara-micro Show documentation
Micro Distribution of the Payara Project
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2016 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
package org.apache.catalina.security;
import org.apache.catalina.Globals;
import org.apache.catalina.LogFacade;
import org.apache.catalina.util.StringManager;
import javax.security.auth.Subject;
import javax.servlet.Filter;
import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.UnavailableException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.Principal;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.HashMap;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This utility class associates a Subject to the current
* AccessControlContext. When a SecurityManager is
* used, the container will always associate the called thread with an
* AccessControlContext containing only the principal of the requested
* Servlet/Filter.
*
* This class uses reflection to invoke the invoke methods.
*
* @author Jean-Francois Arcand
*/
public final class SecurityUtil{
private final static int INIT= 0;
private final static int SERVICE = 1;
private final static int DOFILTER = 1;
private final static int DESTROY = 2;
private final static String INIT_METHOD = "init";
private final static String DOFILTER_METHOD = "doFilter";
private final static String SERVICE_METHOD = "service";
private final static String DESTROY_METHOD = "destroy";
/**
* Cache every object for which we are creating method on it.
*/
private static HashMap objectCache =
new HashMap();
private static final Logger log = LogFacade.getLogger();
private static final ResourceBundle rb = log.getResourceBundle();
private static boolean packageDefinitionEnabled = (
System.getProperty("package.definition") == null ||
System.getProperty("package.definition").equals("")) ? false : true;
// START SJS WS 7.0 6236329
/**
* Do we need to execute all invokation under a Subject.doAs call.
*/
public static final boolean executeUnderSubjectDoAs = true;
// END SJS WS 7.0 6236329
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param methodName the method to apply the security restriction
* @param targetObject the Servlet on which the method will
* be called.
*/
public static void doAsPrivilege(final String methodName,
final Servlet targetObject) throws java.lang.Exception{
doAsPrivilege(methodName, targetObject, null, null, null);
}
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param methodName the method to apply the security restriction
* @param targetObject the Servlet on which the method will
* be called.
* @param targetType Class array used to instantiate a i
* Method object.
* @param targetObject Object array contains the runtime
* parameters instance.
*/
public static void doAsPrivilege(final String methodName,
final Servlet targetObject,
final Class[] targetType,
final Object[] targetArguments)
throws java.lang.Exception{
doAsPrivilege(methodName,
targetObject,
targetType,
targetArguments,
null);
}
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param methodName the method to apply the security restriction
* @param targetObject the Servlet on which the method will
* be called.
* @param targetType Class array used to instantiate a
* Method object.
* @param targetArguments Object array contains the
* runtime parameters instance.
* @param principal the Principal to which the security
* privilege apply..
*/
public static void doAsPrivilege(final String methodName,
final Servlet targetObject,
final Class[] targetType,
final Object[] targetArguments,
Principal principal)
throws java.lang.Exception{
Method method = null;
Method[] methodsCache = null;
if(objectCache.containsKey(targetObject)){
methodsCache = objectCache.get(targetObject);
method = findMethod(methodsCache, methodName);
if (method == null){
method = createMethodAndCacheIt(methodsCache,
methodName,
targetObject,
targetType);
}
} else {
method = createMethodAndCacheIt(methodsCache,
methodName,
targetObject,
targetType);
}
execute(method, targetObject, targetArguments, principal);
}
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param methodName the method to apply the security restriction
* @param targetObject the Filter on which the method will
* be called.
*/
public static void doAsPrivilege(final String methodName,
final Filter targetObject)
throws java.lang.Exception{
doAsPrivilege(methodName, targetObject, null, null);
}
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param methodName the method to apply the security restriction
* @param targetObject the Filter on which the method will
* be called.
* @param targetType Class array used to instantiate a
* Method object.
* @param targetArguments Object array contains the
* runtime parameters instance.
*/
public static void doAsPrivilege(final String methodName,
final Filter targetObject,
final Class[] targetType,
final Object[] targetArguments)
throws java.lang.Exception{
doAsPrivilege(
methodName, targetObject, targetType, targetArguments, null);
}
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param methodName the method to apply the security restriction
* @param targetObject the Filter on which the method will
* be called.
* @param targetType Class array used to instantiate a
* Method object.
* @param targetArguments Object array contains the
* runtime parameters instance.
* @param principal the Principal to which the security
* privilege apply
*/
public static void doAsPrivilege(final String methodName,
final Filter targetObject,
final Class[] targetType,
final Object[] targetArguments,
Principal principal)
throws java.lang.Exception{
Method method = null;
Method[] methodsCache = null;
if(objectCache.containsKey(targetObject)){
methodsCache = objectCache.get(targetObject);
method = findMethod(methodsCache, methodName);
if (method == null){
method = createMethodAndCacheIt(methodsCache,
methodName,
targetObject,
targetType);
}
} else {
method = createMethodAndCacheIt(methodsCache,
methodName,
targetObject,
targetType);
}
execute(method, targetObject, targetArguments, principal);
}
/**
* Perform work as a particular Subject. Here the work
* will be granted to a null subject.
*
* @param method the method to apply the security restriction
* @param targetObject the Servlet on which the method will
* be called.
* @param targetArguments Object array contains the
* runtime parameters instance.
* @param principal the Principal to which the security
* privilege apply..
*/
private static void execute(final Method method,
final Object targetObject,
final Object[] targetArguments,
Principal principal)
throws java.lang.Exception{
try{
Subject subject = null;
PrivilegedExceptionAction pea =
new PrivilegedExceptionAction(){
public Void run() throws Exception{
method.invoke(targetObject, targetArguments);
return null;
}
};
// The first argument is always the request object
if (targetArguments != null
&& targetArguments[0] instanceof HttpServletRequest){
HttpServletRequest request =
(HttpServletRequest)targetArguments[0];
boolean hasSubject = false;
HttpSession session = request.getSession(false);
if (session != null){
subject =
(Subject)session.getAttribute(Globals.SUBJECT_ATTR);
hasSubject = (subject != null);
}
if (subject == null){
subject = new Subject();
if (principal != null){
subject.getPrincipals().add(principal);
}
}
if (session != null && !hasSubject) {
session.setAttribute(Globals.SUBJECT_ATTR, subject);
}
}
Subject.doAsPrivileged(subject, pea, null);
} catch( PrivilegedActionException pe) {
Throwable e;
if (pe.getException() instanceof InvocationTargetException) {
e = ((InvocationTargetException)pe.getException())
.getTargetException();
} else {
e = pe;
}
if (log.isLoggable(Level.FINE)){
log.log(Level.FINE, LogFacade.PRIVILEGE_ACTION_EXCEPTION, e);
}
if (e instanceof UnavailableException)
throw (UnavailableException) e;
else if (e instanceof ServletException)
throw (ServletException) e;
else if (e instanceof IOException)
throw (IOException) e;
else if (e instanceof RuntimeException)
throw (RuntimeException) e;
else
throw new ServletException(e.getMessage(), e);
}
}
/**
* Find a method stored within the cache.
* @param methodsCache the cache used to store method instance
* @param methodName the method to apply the security restriction
* @return the method instance, null if not yet created.
*/
private static Method findMethod(Method[] methodsCache,
String methodName){
if (methodName.equalsIgnoreCase(INIT_METHOD)
&& methodsCache[INIT] != null){
return methodsCache[INIT];
} else if (methodName.equalsIgnoreCase(DESTROY_METHOD)
&& methodsCache[DESTROY] != null){
return methodsCache[DESTROY];
} else if (methodName.equalsIgnoreCase(SERVICE_METHOD)
&& methodsCache[SERVICE] != null){
return methodsCache[SERVICE];
} else if (methodName.equalsIgnoreCase(DOFILTER_METHOD)
&& methodsCache[DOFILTER] != null){
return methodsCache[DOFILTER];
}
return null;
}
/**
* Create the method and cache it for further re-use.
* @param methodsCache the cache used to store method instance
* @param methodName the method to apply the security restriction
* @param targetObject the Servlet on which the method will
* be called.
* @param targetType Class array used to instantiate a
* Method object.
* @return the method instance.
*/
private static Method createMethodAndCacheIt(Method[] methodsCache,
String methodName,
Object targetObject,
Class[] targetType)
throws Exception{
if ( methodsCache == null){
methodsCache = new Method[3];
}
Method method =
targetObject.getClass().getMethod(methodName, targetType);
if (methodName.equalsIgnoreCase(INIT_METHOD)){
methodsCache[INIT] = method;
} else if (methodName.equalsIgnoreCase(DESTROY_METHOD)){
methodsCache[DESTROY] = method;
} else if (methodName.equalsIgnoreCase(SERVICE_METHOD)){
methodsCache[SERVICE] = method;
} else if (methodName.equalsIgnoreCase(DOFILTER_METHOD)){
methodsCache[DOFILTER] = method;
}
objectCache.put(targetObject, methodsCache );
return method;
}
/**
* Remove the object from the cache.
*/
public static void remove(Object cachedObject){
objectCache.remove(cachedObject);
}
/**
* Return the SecurityManager only if Security is enabled AND
* package protection mechanism is enabled.
*/
public static boolean isPackageProtectionEnabled(){
if (packageDefinitionEnabled && Globals.IS_SECURITY_ENABLED) {
return true;
}
return false;
}
// START OF SJS WS 7.0 6236329
/**
* Return true if a SecurityManager is used and is
* isDoAsRequired is required.
*/
public static boolean executeUnderSubjectDoAs(){
if (executeUnderSubjectDoAs && Globals.IS_SECURITY_ENABLED) {
return true;
}
return false;
}
// END OF SJS WS 7.0 6236329
}